clang  6.0.0svn
ContinuationIndenter.cpp
Go to the documentation of this file.
1 //===--- ContinuationIndenter.cpp - Format C++ code -----------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// \file
11 /// \brief This file implements the continuation indenter.
12 ///
13 //===----------------------------------------------------------------------===//
14 
15 #include "ContinuationIndenter.h"
16 #include "BreakableToken.h"
17 #include "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 the length of everything up to the first possible line break after
30 // the ), ], } or > matching \c Tok.
31 static unsigned getLengthToMatchingParen(const FormatToken &Tok) {
32  if (!Tok.MatchingParen)
33  return 0;
35  while (End->Next && !End->Next->CanBreakBefore) {
36  End = End->Next;
37  }
38  return End->TotalLength - Tok.TotalLength + 1;
39 }
40 
41 static unsigned getLengthToNextOperator(const FormatToken &Tok) {
42  if (!Tok.NextOperator)
43  return 0;
44  return Tok.NextOperator->TotalLength - Tok.TotalLength;
45 }
46 
47 // Returns \c true if \c Tok is the "." or "->" of a call and starts the next
48 // segment of a builder type call.
50  return Tok.isMemberAccess() && Tok.Previous && Tok.Previous->closesScope();
51 }
52 
53 // Returns \c true if \c Current starts a new parameter.
54 static bool startsNextParameter(const FormatToken &Current,
55  const FormatStyle &Style) {
56  const FormatToken &Previous = *Current.Previous;
57  if (Current.is(TT_CtorInitializerComma) &&
59  return true;
60  if (Style.Language == FormatStyle::LK_Proto && Current.is(TT_SelectorName))
61  return true;
62  return Previous.is(tok::comma) && !Current.isTrailingComment() &&
63  ((Previous.isNot(TT_CtorInitializerComma) ||
66  (Previous.isNot(TT_InheritanceComma) ||
68 }
69 
70 static bool opensProtoMessageField(const FormatToken &LessTok,
71  const FormatStyle &Style) {
72  if (LessTok.isNot(tok::less))
73  return false;
74  return Style.Language == FormatStyle::LK_TextProto ||
75  (Style.Language == FormatStyle::LK_Proto &&
76  (LessTok.NestingLevel > 0 ||
77  (LessTok.Previous && LessTok.Previous->is(tok::equal))));
78 }
79 
80 // Returns the delimiter of a raw string literal, or None if TokenText is not
81 // the text of a raw string literal. The delimiter could be the empty string.
82 // For example, the delimiter of R"deli(cont)deli" is deli.
83 static llvm::Optional<StringRef> getRawStringDelimiter(StringRef TokenText) {
84  if (TokenText.size() < 5 // The smallest raw string possible is 'R"()"'.
85  || !TokenText.startswith("R\"") || !TokenText.endswith("\""))
86  return None;
87 
88  // A raw string starts with 'R"<delimiter>(' and delimiter is ascii and has
89  // size at most 16 by the standard, so the first '(' must be among the first
90  // 19 bytes.
91  size_t LParenPos = TokenText.substr(0, 19).find_first_of('(');
92  if (LParenPos == StringRef::npos)
93  return None;
94  StringRef Delimiter = TokenText.substr(2, LParenPos - 2);
95 
96  // Check that the string ends in ')Delimiter"'.
97  size_t RParenPos = TokenText.size() - Delimiter.size() - 2;
98  if (TokenText[RParenPos] != ')')
99  return None;
100  if (!TokenText.substr(RParenPos + 1).startswith(Delimiter))
101  return None;
102  return Delimiter;
103 }
104 
106  const FormatStyle &CodeStyle) {
107  for (const auto &RawStringFormat : CodeStyle.RawStringFormats) {
109  if (!getPredefinedStyle(RawStringFormat.BasedOnStyle,
110  RawStringFormat.Language, &Style)) {
111  Style = getLLVMStyle();
112  Style.Language = RawStringFormat.Language;
113  }
114  Style.ColumnLimit = CodeStyle.ColumnLimit;
115  DelimiterStyle.insert({RawStringFormat.Delimiter, Style});
116  }
117 }
118 
120 RawStringFormatStyleManager::get(StringRef Delimiter) const {
121  auto It = DelimiterStyle.find(Delimiter);
122  if (It == DelimiterStyle.end())
123  return None;
124  return It->second;
125 }
126 
128  const AdditionalKeywords &Keywords,
129  const SourceManager &SourceMgr,
130  WhitespaceManager &Whitespaces,
132  bool BinPackInconclusiveFunctions)
133  : Style(Style), Keywords(Keywords), SourceMgr(SourceMgr),
134  Whitespaces(Whitespaces), Encoding(Encoding),
135  BinPackInconclusiveFunctions(BinPackInconclusiveFunctions),
136  CommentPragmasRegex(Style.CommentPragmas), RawStringFormats(Style) {}
137 
139  unsigned FirstStartColumn,
140  const AnnotatedLine *Line,
141  bool DryRun) {
143  State.FirstIndent = FirstIndent;
144  if (FirstStartColumn && Line->First->NewlinesBefore == 0)
145  State.Column = FirstStartColumn;
146  else
147  State.Column = FirstIndent;
148  // With preprocessor directive indentation, the line starts on column 0
149  // since it's indented after the hash, but FirstIndent is set to the
150  // preprocessor indent.
152  (Line->Type == LT_PreprocessorDirective ||
153  Line->Type == LT_ImportStatement))
154  State.Column = 0;
155  State.Line = Line;
156  State.NextToken = Line->First;
157  State.Stack.push_back(ParenState(FirstIndent, FirstIndent,
158  /*AvoidBinPacking=*/false,
159  /*NoLineBreak=*/false));
161  State.NoContinuation = false;
162  State.StartOfStringLiteral = 0;
163  State.StartOfLineLevel = 0;
164  State.LowestLevelOnLine = 0;
165  State.IgnoreStackForComparison = false;
166 
167  if (Style.Language == FormatStyle::LK_TextProto) {
168  // We need this in order to deal with the bin packing of text fields at
169  // global scope.
170  State.Stack.back().AvoidBinPacking = true;
171  State.Stack.back().BreakBeforeParameter = true;
172  }
173 
174  // The first token has already been indented and thus consumed.
175  moveStateToNextToken(State, DryRun, /*Newline=*/false);
176  return State;
177 }
178 
180  const FormatToken &Current = *State.NextToken;
181  const FormatToken &Previous = *Current.Previous;
182  assert(&Previous == Current.Previous);
183  if (!Current.CanBreakBefore && !(State.Stack.back().BreakBeforeClosingBrace &&
184  Current.closesBlockOrBlockTypeList(Style)))
185  return false;
186  // The opening "{" of a braced list has to be on the same line as the first
187  // element if it is nested in another braced init list or function call.
188  if (!Current.MustBreakBefore && Previous.is(tok::l_brace) &&
189  Previous.isNot(TT_DictLiteral) && Previous.BlockKind == BK_BracedInit &&
190  Previous.Previous &&
191  Previous.Previous->isOneOf(tok::l_brace, tok::l_paren, tok::comma))
192  return false;
193  // This prevents breaks like:
194  // ...
195  // SomeParameter, OtherParameter).DoSomething(
196  // ...
197  // As they hide "DoSomething" and are generally bad for readability.
198  if (Previous.opensScope() && Previous.isNot(tok::l_brace) &&
199  State.LowestLevelOnLine < State.StartOfLineLevel &&
200  State.LowestLevelOnLine < Current.NestingLevel)
201  return false;
202  if (Current.isMemberAccess() && State.Stack.back().ContainsUnwrappedBuilder)
203  return false;
204 
205  // Don't create a 'hanging' indent if there are multiple blocks in a single
206  // statement.
207  if (Previous.is(tok::l_brace) && State.Stack.size() > 1 &&
208  State.Stack[State.Stack.size() - 2].NestedBlockInlined &&
209  State.Stack[State.Stack.size() - 2].HasMultipleNestedBlocks)
210  return false;
211 
212  // Don't break after very short return types (e.g. "void") as that is often
213  // unexpected.
214  if (Current.is(TT_FunctionDeclarationName) && State.Column < 6) {
216  return false;
217  }
218 
219  // If binary operators are moved to the next line (including commas for some
220  // styles of constructor initializers), that's always ok.
221  if (!Current.isOneOf(TT_BinaryOperator, tok::comma) &&
222  State.Stack.back().NoLineBreakInOperand)
223  return false;
224 
225  return !State.Stack.back().NoLineBreak;
226 }
227 
229  const FormatToken &Current = *State.NextToken;
230  const FormatToken &Previous = *Current.Previous;
231  if (Current.MustBreakBefore || Current.is(TT_InlineASMColon))
232  return true;
233  if (State.Stack.back().BreakBeforeClosingBrace &&
234  Current.closesBlockOrBlockTypeList(Style))
235  return true;
236  if (Previous.is(tok::semi) && State.LineContainsContinuedForLoopSection)
237  return true;
238  if ((startsNextParameter(Current, Style) || Previous.is(tok::semi) ||
239  (Previous.is(TT_TemplateCloser) && Current.is(TT_StartOfName) &&
240  Style.isCpp() &&
241  // FIXME: This is a temporary workaround for the case where clang-format
242  // sets BreakBeforeParameter to avoid bin packing and this creates a
243  // completely unnecessary line break after a template type that isn't
244  // line-wrapped.
245  (Previous.NestingLevel == 1 || Style.BinPackParameters)) ||
246  (Style.BreakBeforeTernaryOperators && Current.is(TT_ConditionalExpr) &&
247  Previous.isNot(tok::question)) ||
248  (!Style.BreakBeforeTernaryOperators &&
249  Previous.is(TT_ConditionalExpr))) &&
250  State.Stack.back().BreakBeforeParameter && !Current.isTrailingComment() &&
251  !Current.isOneOf(tok::r_paren, tok::r_brace))
252  return true;
253  if (((Previous.is(TT_DictLiteral) && Previous.is(tok::l_brace)) ||
254  (Previous.is(TT_ArrayInitializerLSquare) &&
255  Previous.ParameterCount > 1) ||
256  opensProtoMessageField(Previous, Style)) &&
257  Style.ColumnLimit > 0 &&
258  getLengthToMatchingParen(Previous) + State.Column - 1 >
259  getColumnLimit(State))
260  return true;
261 
262  const FormatToken &BreakConstructorInitializersToken =
264  ? Previous
265  : Current;
266  if (BreakConstructorInitializersToken.is(TT_CtorInitializerColon) &&
267  (State.Column + State.Line->Last->TotalLength - Previous.TotalLength >
268  getColumnLimit(State) ||
269  State.Stack.back().BreakBeforeParameter) &&
272  Style.ColumnLimit != 0))
273  return true;
274 
275  if (Current.is(TT_ObjCMethodExpr) && !Previous.is(TT_SelectorName) &&
276  State.Line->startsWith(TT_ObjCMethodSpecifier))
277  return true;
278  if (Current.is(TT_SelectorName) && State.Stack.back().ObjCSelectorNameFound &&
279  State.Stack.back().BreakBeforeParameter)
280  return true;
281 
282  unsigned NewLineColumn = getNewLineColumn(State);
283  if (Current.isMemberAccess() && Style.ColumnLimit != 0 &&
284  State.Column + getLengthToNextOperator(Current) > Style.ColumnLimit &&
285  (State.Column > NewLineColumn ||
286  Current.NestingLevel < State.StartOfLineLevel))
287  return true;
288 
289  if (startsSegmentOfBuilderTypeCall(Current) &&
290  (State.Stack.back().CallContinuation != 0 ||
291  State.Stack.back().BreakBeforeParameter) &&
292  // JavaScript is treated different here as there is a frequent pattern:
293  // SomeFunction(function() {
294  // ...
295  // }.bind(...));
296  // FIXME: We should find a more generic solution to this problem.
297  !(State.Column <= NewLineColumn &&
299  return true;
300 
301  if (State.Column <= NewLineColumn)
302  return false;
303 
305  (NewLineColumn == State.FirstIndent + Style.ContinuationIndentWidth ||
306  Previous.is(tok::comma) || Current.NestingLevel < 2) &&
307  !Previous.isOneOf(tok::kw_return, tok::lessless, tok::at) &&
308  !Previous.isOneOf(TT_InlineASMColon, TT_ConditionalExpr) &&
309  nextIsMultilineString(State))
310  return true;
311 
312  // Using CanBreakBefore here and below takes care of the decision whether the
313  // current style uses wrapping before or after operators for the given
314  // operator.
315  if (Previous.is(TT_BinaryOperator) && Current.CanBreakBefore) {
316  // If we need to break somewhere inside the LHS of a binary expression, we
317  // should also break after the operator. Otherwise, the formatting would
318  // hide the operator precedence, e.g. in:
319  // if (aaaaaaaaaaaaaa ==
320  // bbbbbbbbbbbbbb && c) {..
321  // For comparisons, we only apply this rule, if the LHS is a binary
322  // expression itself as otherwise, the line breaks seem superfluous.
323  // We need special cases for ">>" which we have split into two ">" while
324  // lexing in order to make template parsing easier.
325  bool IsComparison = (Previous.getPrecedence() == prec::Relational ||
326  Previous.getPrecedence() == prec::Equality) &&
327  Previous.Previous &&
328  Previous.Previous->isNot(TT_BinaryOperator); // For >>.
329  bool LHSIsBinaryExpr =
330  Previous.Previous && Previous.Previous->EndsBinaryExpression;
331  if ((!IsComparison || LHSIsBinaryExpr) && !Current.isTrailingComment() &&
332  Previous.getPrecedence() != prec::Assignment &&
333  State.Stack.back().BreakBeforeParameter)
334  return true;
335  } else if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore &&
336  State.Stack.back().BreakBeforeParameter) {
337  return true;
338  }
339 
340  // Same as above, but for the first "<<" operator.
341  if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator) &&
342  State.Stack.back().BreakBeforeParameter &&
343  State.Stack.back().FirstLessLess == 0)
344  return true;
345 
346  if (Current.NestingLevel == 0 && !Current.isTrailingComment()) {
347  // Always break after "template <...>" and leading annotations. This is only
348  // for cases where the entire line does not fit on a single line as a
349  // different LineFormatter would be used otherwise.
350  if (Previous.ClosesTemplateDeclaration)
351  return true;
352  if (Previous.is(TT_FunctionAnnotationRParen))
353  return true;
354  if (Previous.is(TT_LeadingJavaAnnotation) && Current.isNot(tok::l_paren) &&
355  Current.isNot(TT_LeadingJavaAnnotation))
356  return true;
357  }
358 
359  // If the return type spans multiple lines, wrap before the function name.
360  if ((Current.is(TT_FunctionDeclarationName) ||
361  (Current.is(tok::kw_operator) && !Previous.is(tok::coloncolon))) &&
362  !Previous.is(tok::kw_template) && State.Stack.back().BreakBeforeParameter)
363  return true;
364 
365  // The following could be precomputed as they do not depend on the state.
366  // However, as they should take effect only if the UnwrappedLine does not fit
367  // into the ColumnLimit, they are checked here in the ContinuationIndenter.
368  if (Style.ColumnLimit != 0 && Previous.BlockKind == BK_Block &&
369  Previous.is(tok::l_brace) && !Current.isOneOf(tok::r_brace, tok::comment))
370  return true;
371 
372  if (Current.is(tok::lessless) &&
373  ((Previous.is(tok::identifier) && Previous.TokenText == "endl") ||
374  (Previous.Tok.isLiteral() && (Previous.TokenText.endswith("\\n\"") ||
375  Previous.TokenText == "\'\\n\'"))))
376  return true;
377 
378  if (Previous.is(TT_BlockComment) && Previous.IsMultiline)
379  return true;
380 
381  if (State.NoContinuation)
382  return true;
383 
384  return false;
385 }
386 
388  bool DryRun,
389  unsigned ExtraSpaces) {
390  const FormatToken &Current = *State.NextToken;
391 
392  assert(!State.Stack.empty());
393  State.NoContinuation = false;
394 
395  if ((Current.is(TT_ImplicitStringLiteral) &&
396  (Current.Previous->Tok.getIdentifierInfo() == nullptr ||
398  tok::pp_not_keyword))) {
399  unsigned EndColumn =
400  SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getEnd());
401  if (Current.LastNewlineOffset != 0) {
402  // If there is a newline within this token, the final column will solely
403  // determined by the current end column.
404  State.Column = EndColumn;
405  } else {
406  unsigned StartColumn =
407  SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getBegin());
408  assert(EndColumn >= StartColumn);
409  State.Column += EndColumn - StartColumn;
410  }
411  moveStateToNextToken(State, DryRun, /*Newline=*/false);
412  return 0;
413  }
414 
415  unsigned Penalty = 0;
416  if (Newline)
417  Penalty = addTokenOnNewLine(State, DryRun);
418  else
419  addTokenOnCurrentLine(State, DryRun, ExtraSpaces);
420 
421  return moveStateToNextToken(State, DryRun, Newline) + Penalty;
422 }
423 
424 void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
425  unsigned ExtraSpaces) {
426  FormatToken &Current = *State.NextToken;
427  const FormatToken &Previous = *State.NextToken->Previous;
428  if (Current.is(tok::equal) &&
429  (State.Line->First->is(tok::kw_for) || Current.NestingLevel == 0) &&
430  State.Stack.back().VariablePos == 0) {
431  State.Stack.back().VariablePos = State.Column;
432  // Move over * and & if they are bound to the variable name.
433  const FormatToken *Tok = &Previous;
434  while (Tok && State.Stack.back().VariablePos >= Tok->ColumnWidth) {
435  State.Stack.back().VariablePos -= Tok->ColumnWidth;
436  if (Tok->SpacesRequiredBefore != 0)
437  break;
438  Tok = Tok->Previous;
439  }
440  if (Previous.PartOfMultiVariableDeclStmt)
441  State.Stack.back().LastSpace = State.Stack.back().VariablePos;
442  }
443 
444  unsigned Spaces = Current.SpacesRequiredBefore + ExtraSpaces;
445 
446  // Indent preprocessor directives after the hash if required.
447  int PPColumnCorrection = 0;
449  Previous.is(tok::hash) && State.FirstIndent > 0 &&
450  (State.Line->Type == LT_PreprocessorDirective ||
451  State.Line->Type == LT_ImportStatement)) {
452  Spaces += State.FirstIndent;
453 
454  // For preprocessor indent with tabs, State.Column will be 1 because of the
455  // hash. This causes second-level indents onward to have an extra space
456  // after the tabs. We avoid this misalignment by subtracting 1 from the
457  // column value passed to replaceWhitespace().
458  if (Style.UseTab != FormatStyle::UT_Never)
459  PPColumnCorrection = -1;
460  }
461 
462  if (!DryRun)
463  Whitespaces.replaceWhitespace(Current, /*Newlines=*/0, Spaces,
464  State.Column + Spaces + PPColumnCorrection);
465 
466  // If "BreakBeforeInheritanceComma" mode, don't break within the inheritance
467  // declaration unless there is multiple inheritance.
468  if (Style.BreakBeforeInheritanceComma && Current.is(TT_InheritanceColon))
469  State.Stack.back().NoLineBreak = true;
470 
471  if (Current.is(TT_SelectorName) &&
472  !State.Stack.back().ObjCSelectorNameFound) {
473  unsigned MinIndent =
475  State.Stack.back().Indent);
476  unsigned FirstColonPos = State.Column + Spaces + Current.ColumnWidth;
477  if (Current.LongestObjCSelectorName == 0)
478  State.Stack.back().AlignColons = false;
479  else if (MinIndent + Current.LongestObjCSelectorName > FirstColonPos)
480  State.Stack.back().ColonPos = MinIndent + Current.LongestObjCSelectorName;
481  else
482  State.Stack.back().ColonPos = FirstColonPos;
483  }
484 
485  // In "AlwaysBreak" mode, enforce wrapping directly after the parenthesis by
486  // disallowing any further line breaks if there is no line break after the
487  // opening parenthesis. Don't break if it doesn't conserve columns.
489  Previous.isOneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) &&
490  State.Column > getNewLineColumn(State) &&
491  (!Previous.Previous || !Previous.Previous->isOneOf(
492  tok::kw_for, tok::kw_while, tok::kw_switch)) &&
493  // Don't do this for simple (no expressions) one-argument function calls
494  // as that feels like needlessly wasting whitespace, e.g.:
495  //
496  // caaaaaaaaaaaall(
497  // caaaaaaaaaaaall(
498  // caaaaaaaaaaaall(
499  // caaaaaaaaaaaaaaaaaaaaaaall(aaaaaaaaaaaaaa, aaaaaaaaa))));
500  Current.FakeLParens.size() > 0 &&
501  Current.FakeLParens.back() > prec::Unknown)
502  State.Stack.back().NoLineBreak = true;
503  if (Previous.is(TT_TemplateString) && Previous.opensScope())
504  State.Stack.back().NoLineBreak = true;
505 
507  Previous.opensScope() && Previous.isNot(TT_ObjCMethodExpr) &&
508  (Current.isNot(TT_LineComment) || Previous.BlockKind == BK_BracedInit))
509  State.Stack.back().Indent = State.Column + Spaces;
510  if (State.Stack.back().AvoidBinPacking && startsNextParameter(Current, Style))
511  State.Stack.back().NoLineBreak = true;
512  if (startsSegmentOfBuilderTypeCall(Current) &&
513  State.Column > getNewLineColumn(State))
514  State.Stack.back().ContainsUnwrappedBuilder = true;
515 
516  if (Current.is(TT_LambdaArrow) && Style.Language == FormatStyle::LK_Java)
517  State.Stack.back().NoLineBreak = true;
518  if (Current.isMemberAccess() && Previous.is(tok::r_paren) &&
519  (Previous.MatchingParen &&
520  (Previous.TotalLength - Previous.MatchingParen->TotalLength > 10)))
521  // If there is a function call with long parameters, break before trailing
522  // calls. This prevents things like:
523  // EXPECT_CALL(SomeLongParameter).Times(
524  // 2);
525  // We don't want to do this for short parameters as they can just be
526  // indexes.
527  State.Stack.back().NoLineBreak = true;
528 
529  // Don't allow the RHS of an operator to be split over multiple lines unless
530  // there is a line-break right after the operator.
531  // Exclude relational operators, as there, it is always more desirable to
532  // have the LHS 'left' of the RHS.
533  const FormatToken *P = Current.getPreviousNonComment();
534  if (!Current.is(tok::comment) && P &&
535  (P->isOneOf(TT_BinaryOperator, tok::comma) ||
536  (P->is(TT_ConditionalExpr) && P->is(tok::colon))) &&
537  !P->isOneOf(TT_OverloadedOperator, TT_CtorInitializerComma) &&
540  bool BreakBeforeOperator =
541  P->MustBreakBefore || P->is(tok::lessless) ||
542  (P->is(TT_BinaryOperator) &&
544  (P->is(TT_ConditionalExpr) && Style.BreakBeforeTernaryOperators);
545  // Don't do this if there are only two operands. In these cases, there is
546  // always a nice vertical separation between them and the extra line break
547  // does not help.
548  bool HasTwoOperands =
549  P->OperatorIndex == 0 && !P->NextOperator && !P->is(TT_ConditionalExpr);
550  if ((!BreakBeforeOperator && !(HasTwoOperands && Style.AlignOperands)) ||
551  (!State.Stack.back().LastOperatorWrapped && BreakBeforeOperator))
552  State.Stack.back().NoLineBreakInOperand = true;
553  }
554 
555  State.Column += Spaces;
556  if (Current.isNot(tok::comment) && Previous.is(tok::l_paren) &&
557  Previous.Previous &&
558  (Previous.Previous->isOneOf(tok::kw_if, tok::kw_for) ||
559  Previous.Previous->endsSequence(tok::kw_constexpr, tok::kw_if))) {
560  // Treat the condition inside an if as if it was a second function
561  // parameter, i.e. let nested calls have a continuation indent.
562  State.Stack.back().LastSpace = State.Column;
563  State.Stack.back().NestedBlockIndent = State.Column;
564  } else if (!Current.isOneOf(tok::comment, tok::caret) &&
565  ((Previous.is(tok::comma) &&
566  !Previous.is(TT_OverloadedOperator)) ||
567  (Previous.is(tok::colon) && Previous.is(TT_ObjCMethodExpr)))) {
568  State.Stack.back().LastSpace = State.Column;
569  } else if (Previous.is(TT_CtorInitializerColon) &&
572  State.Stack.back().Indent = State.Column;
573  State.Stack.back().LastSpace = State.Column;
574  } else if ((Previous.isOneOf(TT_BinaryOperator, TT_ConditionalExpr,
575  TT_CtorInitializerColon)) &&
576  ((Previous.getPrecedence() != prec::Assignment &&
577  (Previous.isNot(tok::lessless) || Previous.OperatorIndex != 0 ||
578  Previous.NextOperator)) ||
579  Current.StartsBinaryExpression)) {
580  // Indent relative to the RHS of the expression unless this is a simple
581  // assignment without binary expression on the RHS. Also indent relative to
582  // unary operators and the colons of constructor initializers.
583  State.Stack.back().LastSpace = State.Column;
584  } else if (Previous.is(TT_InheritanceColon)) {
585  State.Stack.back().Indent = State.Column;
586  State.Stack.back().LastSpace = State.Column;
587  } else if (Previous.opensScope()) {
588  // If a function has a trailing call, indent all parameters from the
589  // opening parenthesis. This avoids confusing indents like:
590  // OuterFunction(InnerFunctionCall( // break
591  // ParameterToInnerFunction)) // break
592  // .SecondInnerFunctionCall();
593  bool HasTrailingCall = false;
594  if (Previous.MatchingParen) {
595  const FormatToken *Next = Previous.MatchingParen->getNextNonComment();
596  HasTrailingCall = Next && Next->isMemberAccess();
597  }
598  if (HasTrailingCall && State.Stack.size() > 1 &&
599  State.Stack[State.Stack.size() - 2].CallContinuation == 0)
600  State.Stack.back().LastSpace = State.Column;
601  }
602 }
603 
604 unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
605  bool DryRun) {
606  FormatToken &Current = *State.NextToken;
607  const FormatToken &Previous = *State.NextToken->Previous;
608 
609  // Extra penalty that needs to be added because of the way certain line
610  // breaks are chosen.
611  unsigned Penalty = 0;
612 
613  const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
614  const FormatToken *NextNonComment = Previous.getNextNonComment();
615  if (!NextNonComment)
616  NextNonComment = &Current;
617  // The first line break on any NestingLevel causes an extra penalty in order
618  // prefer similar line breaks.
619  if (!State.Stack.back().ContainsLineBreak)
620  Penalty += 15;
621  State.Stack.back().ContainsLineBreak = true;
622 
623  Penalty += State.NextToken->SplitPenalty;
624 
625  // Breaking before the first "<<" is generally not desirable if the LHS is
626  // short. Also always add the penalty if the LHS is split over multiple lines
627  // to avoid unnecessary line breaks that just work around this penalty.
628  if (NextNonComment->is(tok::lessless) &&
629  State.Stack.back().FirstLessLess == 0 &&
630  (State.Column <= Style.ColumnLimit / 3 ||
631  State.Stack.back().BreakBeforeParameter))
632  Penalty += Style.PenaltyBreakFirstLessLess;
633 
634  State.Column = getNewLineColumn(State);
635 
636  // Indent nested blocks relative to this column, unless in a very specific
637  // JavaScript special case where:
638  //
639  // var loooooong_name =
640  // function() {
641  // // code
642  // }
643  //
644  // is common and should be formatted like a free-standing function. The same
645  // goes for wrapping before the lambda return type arrow.
646  if (!Current.is(TT_LambdaArrow) &&
648  Current.NestingLevel != 0 || !PreviousNonComment ||
649  !PreviousNonComment->is(tok::equal) ||
650  !Current.isOneOf(Keywords.kw_async, Keywords.kw_function)))
651  State.Stack.back().NestedBlockIndent = State.Column;
652 
653  if (NextNonComment->isMemberAccess()) {
654  if (State.Stack.back().CallContinuation == 0)
655  State.Stack.back().CallContinuation = State.Column;
656  } else if (NextNonComment->is(TT_SelectorName)) {
657  if (!State.Stack.back().ObjCSelectorNameFound) {
658  if (NextNonComment->LongestObjCSelectorName == 0) {
659  State.Stack.back().AlignColons = false;
660  } else {
661  State.Stack.back().ColonPos =
663  ? std::max(State.Stack.back().Indent,
664  State.FirstIndent + Style.ContinuationIndentWidth)
665  : State.Stack.back().Indent) +
666  NextNonComment->LongestObjCSelectorName;
667  }
668  } else if (State.Stack.back().AlignColons &&
669  State.Stack.back().ColonPos <= NextNonComment->ColumnWidth) {
670  State.Stack.back().ColonPos = State.Column + NextNonComment->ColumnWidth;
671  }
672  } else if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
673  PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) {
674  // FIXME: This is hacky, find a better way. The problem is that in an ObjC
675  // method expression, the block should be aligned to the line starting it,
676  // e.g.:
677  // [aaaaaaaaaaaaaaa aaaaaaaaa: \\ break for some reason
678  // ^(int *i) {
679  // // ...
680  // }];
681  // Thus, we set LastSpace of the next higher NestingLevel, to which we move
682  // when we consume all of the "}"'s FakeRParens at the "{".
683  if (State.Stack.size() > 1)
684  State.Stack[State.Stack.size() - 2].LastSpace =
685  std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) +
687  }
688 
689  if ((PreviousNonComment &&
690  PreviousNonComment->isOneOf(tok::comma, tok::semi) &&
691  !State.Stack.back().AvoidBinPacking) ||
692  Previous.is(TT_BinaryOperator))
693  State.Stack.back().BreakBeforeParameter = false;
694  if (Previous.isOneOf(TT_TemplateCloser, TT_JavaAnnotation) &&
695  Current.NestingLevel == 0)
696  State.Stack.back().BreakBeforeParameter = false;
697  if (NextNonComment->is(tok::question) ||
698  (PreviousNonComment && PreviousNonComment->is(tok::question)))
699  State.Stack.back().BreakBeforeParameter = true;
700  if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore)
701  State.Stack.back().BreakBeforeParameter = false;
702 
703  if (!DryRun) {
704  unsigned MaxEmptyLinesToKeep = Style.MaxEmptyLinesToKeep + 1;
705  if (Current.is(tok::r_brace) && Current.MatchingParen &&
706  // Only strip trailing empty lines for l_braces that have children, i.e.
707  // for function expressions (lambdas, arrows, etc).
708  !Current.MatchingParen->Children.empty()) {
709  // lambdas and arrow functions are expressions, thus their r_brace is not
710  // on its own line, and thus not covered by UnwrappedLineFormatter's logic
711  // about removing empty lines on closing blocks. Special case them here.
712  MaxEmptyLinesToKeep = 1;
713  }
714  unsigned Newlines = std::max(
715  1u, std::min(Current.NewlinesBefore, MaxEmptyLinesToKeep));
716  bool ContinuePPDirective =
717  State.Line->InPPDirective && State.Line->Type != LT_ImportStatement;
718  Whitespaces.replaceWhitespace(Current, Newlines, State.Column, State.Column,
719  ContinuePPDirective);
720  }
721 
722  if (!Current.isTrailingComment())
723  State.Stack.back().LastSpace = State.Column;
724  if (Current.is(tok::lessless))
725  // If we are breaking before a "<<", we always want to indent relative to
726  // RHS. This is necessary only for "<<", as we special-case it and don't
727  // always indent relative to the RHS.
728  State.Stack.back().LastSpace += 3; // 3 -> width of "<< ".
729 
730  State.StartOfLineLevel = Current.NestingLevel;
731  State.LowestLevelOnLine = Current.NestingLevel;
732 
733  // Any break on this level means that the parent level has been broken
734  // and we need to avoid bin packing there.
735  bool NestedBlockSpecialCase =
736  !Style.isCpp() && Current.is(tok::r_brace) && State.Stack.size() > 1 &&
737  State.Stack[State.Stack.size() - 2].NestedBlockInlined;
738  if (!NestedBlockSpecialCase)
739  for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i)
740  State.Stack[i].BreakBeforeParameter = true;
741 
742  if (PreviousNonComment &&
743  !PreviousNonComment->isOneOf(tok::comma, tok::colon, tok::semi) &&
744  (PreviousNonComment->isNot(TT_TemplateCloser) ||
745  Current.NestingLevel != 0) &&
746  !PreviousNonComment->isOneOf(
747  TT_BinaryOperator, TT_FunctionAnnotationRParen, TT_JavaAnnotation,
748  TT_LeadingJavaAnnotation) &&
749  Current.isNot(TT_BinaryOperator) && !PreviousNonComment->opensScope())
750  State.Stack.back().BreakBeforeParameter = true;
751 
752  // If we break after { or the [ of an array initializer, we should also break
753  // before the corresponding } or ].
754  if (PreviousNonComment &&
755  (PreviousNonComment->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
756  opensProtoMessageField(*PreviousNonComment, Style)))
757  State.Stack.back().BreakBeforeClosingBrace = true;
758 
759  if (State.Stack.back().AvoidBinPacking) {
760  // If we are breaking after '(', '{', '<', this is not bin packing
761  // unless AllowAllParametersOfDeclarationOnNextLine is false or this is a
762  // dict/object literal.
763  if (!Previous.isOneOf(tok::l_paren, tok::l_brace, TT_BinaryOperator) ||
765  State.Line->MustBeDeclaration) ||
766  Previous.is(TT_DictLiteral))
767  State.Stack.back().BreakBeforeParameter = true;
768  }
769 
770  return Penalty;
771 }
772 
773 unsigned ContinuationIndenter::getNewLineColumn(const LineState &State) {
774  if (!State.NextToken || !State.NextToken->Previous)
775  return 0;
776  FormatToken &Current = *State.NextToken;
777  const FormatToken &Previous = *Current.Previous;
778  // If we are continuing an expression, we want to use the continuation indent.
779  unsigned ContinuationIndent =
780  std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) +
782  const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
783  const FormatToken *NextNonComment = Previous.getNextNonComment();
784  if (!NextNonComment)
785  NextNonComment = &Current;
786 
787  // Java specific bits.
788  if (Style.Language == FormatStyle::LK_Java &&
789  Current.isOneOf(Keywords.kw_implements, Keywords.kw_extends))
790  return std::max(State.Stack.back().LastSpace,
791  State.Stack.back().Indent + Style.ContinuationIndentWidth);
792 
793  if (NextNonComment->is(tok::l_brace) && NextNonComment->BlockKind == BK_Block)
794  return Current.NestingLevel == 0 ? State.FirstIndent
795  : State.Stack.back().Indent;
796  if ((Current.isOneOf(tok::r_brace, tok::r_square) ||
797  (Current.is(tok::greater) &&
798  (Style.Language == FormatStyle::LK_Proto ||
799  Style.Language == FormatStyle::LK_TextProto))) &&
800  State.Stack.size() > 1) {
801  if (Current.closesBlockOrBlockTypeList(Style))
802  return State.Stack[State.Stack.size() - 2].NestedBlockIndent;
803  if (Current.MatchingParen &&
805  return State.Stack[State.Stack.size() - 2].LastSpace;
806  return State.FirstIndent;
807  }
808  // Indent a closing parenthesis at the previous level if followed by a semi or
809  // opening brace. This allows indentations such as:
810  // foo(
811  // a,
812  // );
813  // function foo(
814  // a,
815  // ) {
816  // code(); //
817  // }
818  if (Current.is(tok::r_paren) && State.Stack.size() > 1 &&
819  (!Current.Next || Current.Next->isOneOf(tok::semi, tok::l_brace)))
820  return State.Stack[State.Stack.size() - 2].LastSpace;
821  if (NextNonComment->is(TT_TemplateString) && NextNonComment->closesScope())
822  return State.Stack[State.Stack.size() - 2].LastSpace;
823  if (Current.is(tok::identifier) && Current.Next &&
824  (Current.Next->is(TT_DictLiteral) ||
825  ((Style.Language == FormatStyle::LK_Proto ||
827  Current.Next->isOneOf(TT_TemplateOpener, tok::l_brace))))
828  return State.Stack.back().Indent;
829  if (NextNonComment->is(TT_ObjCStringLiteral) &&
830  State.StartOfStringLiteral != 0)
831  return State.StartOfStringLiteral - 1;
832  if (NextNonComment->isStringLiteral() && State.StartOfStringLiteral != 0)
833  return State.StartOfStringLiteral;
834  if (NextNonComment->is(tok::lessless) &&
835  State.Stack.back().FirstLessLess != 0)
836  return State.Stack.back().FirstLessLess;
837  if (NextNonComment->isMemberAccess()) {
838  if (State.Stack.back().CallContinuation == 0)
839  return ContinuationIndent;
840  return State.Stack.back().CallContinuation;
841  }
842  if (State.Stack.back().QuestionColumn != 0 &&
843  ((NextNonComment->is(tok::colon) &&
844  NextNonComment->is(TT_ConditionalExpr)) ||
845  Previous.is(TT_ConditionalExpr)))
846  return State.Stack.back().QuestionColumn;
847  if (Previous.is(tok::comma) && State.Stack.back().VariablePos != 0)
848  return State.Stack.back().VariablePos;
849  if ((PreviousNonComment &&
850  (PreviousNonComment->ClosesTemplateDeclaration ||
851  PreviousNonComment->isOneOf(
852  TT_AttributeParen, TT_FunctionAnnotationRParen, TT_JavaAnnotation,
853  TT_LeadingJavaAnnotation))) ||
854  (!Style.IndentWrappedFunctionNames &&
855  NextNonComment->isOneOf(tok::kw_operator, TT_FunctionDeclarationName)))
856  return std::max(State.Stack.back().LastSpace, State.Stack.back().Indent);
857  if (NextNonComment->is(TT_SelectorName)) {
858  if (!State.Stack.back().ObjCSelectorNameFound) {
859  if (NextNonComment->LongestObjCSelectorName == 0)
860  return State.Stack.back().Indent;
861  return (Style.IndentWrappedFunctionNames
862  ? std::max(State.Stack.back().Indent,
863  State.FirstIndent + Style.ContinuationIndentWidth)
864  : State.Stack.back().Indent) +
865  NextNonComment->LongestObjCSelectorName -
866  NextNonComment->ColumnWidth;
867  }
868  if (!State.Stack.back().AlignColons)
869  return State.Stack.back().Indent;
870  if (State.Stack.back().ColonPos > NextNonComment->ColumnWidth)
871  return State.Stack.back().ColonPos - NextNonComment->ColumnWidth;
872  return State.Stack.back().Indent;
873  }
874  if (NextNonComment->is(tok::colon) && NextNonComment->is(TT_ObjCMethodExpr))
875  return State.Stack.back().ColonPos;
876  if (NextNonComment->is(TT_ArraySubscriptLSquare)) {
877  if (State.Stack.back().StartOfArraySubscripts != 0)
878  return State.Stack.back().StartOfArraySubscripts;
879  return ContinuationIndent;
880  }
881 
882  // This ensure that we correctly format ObjC methods calls without inputs,
883  // i.e. where the last element isn't selector like: [callee method];
884  if (NextNonComment->is(tok::identifier) && NextNonComment->FakeRParens == 0 &&
885  NextNonComment->Next && NextNonComment->Next->is(TT_ObjCMethodExpr))
886  return State.Stack.back().Indent;
887 
888  if (NextNonComment->isOneOf(TT_StartOfName, TT_PointerOrReference) ||
889  Previous.isOneOf(tok::coloncolon, tok::equal, TT_JsTypeColon))
890  return ContinuationIndent;
891  if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
892  PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral))
893  return ContinuationIndent;
894  if (NextNonComment->is(TT_CtorInitializerComma))
895  return State.Stack.back().Indent;
896  if (PreviousNonComment && PreviousNonComment->is(TT_CtorInitializerColon) &&
898  return State.Stack.back().Indent;
899  if (NextNonComment->isOneOf(TT_CtorInitializerColon, TT_InheritanceColon,
900  TT_InheritanceComma))
901  return State.FirstIndent + Style.ConstructorInitializerIndentWidth;
902  if (Previous.is(tok::r_paren) && !Current.isBinaryOperator() &&
903  !Current.isOneOf(tok::colon, tok::comment))
904  return ContinuationIndent;
905  if (State.Stack.back().Indent == State.FirstIndent && PreviousNonComment &&
906  PreviousNonComment->isNot(tok::r_brace))
907  // Ensure that we fall back to the continuation indent width instead of
908  // just flushing continuations left.
909  return State.Stack.back().Indent + Style.ContinuationIndentWidth;
910  return State.Stack.back().Indent;
911 }
912 
913 unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
914  bool DryRun, bool Newline) {
915  assert(State.Stack.size());
916  const FormatToken &Current = *State.NextToken;
917 
918  if (Current.isOneOf(tok::comma, TT_BinaryOperator))
919  State.Stack.back().NoLineBreakInOperand = false;
920  if (Current.is(TT_InheritanceColon))
921  State.Stack.back().AvoidBinPacking = true;
922  if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) {
923  if (State.Stack.back().FirstLessLess == 0)
924  State.Stack.back().FirstLessLess = State.Column;
925  else
926  State.Stack.back().LastOperatorWrapped = Newline;
927  }
928  if (Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless))
929  State.Stack.back().LastOperatorWrapped = Newline;
930  if (Current.is(TT_ConditionalExpr) && Current.Previous &&
931  !Current.Previous->is(TT_ConditionalExpr))
932  State.Stack.back().LastOperatorWrapped = Newline;
933  if (Current.is(TT_ArraySubscriptLSquare) &&
934  State.Stack.back().StartOfArraySubscripts == 0)
935  State.Stack.back().StartOfArraySubscripts = State.Column;
936  if (Style.BreakBeforeTernaryOperators && Current.is(tok::question))
937  State.Stack.back().QuestionColumn = State.Column;
938  if (!Style.BreakBeforeTernaryOperators && Current.isNot(tok::colon)) {
939  const FormatToken *Previous = Current.Previous;
940  while (Previous && Previous->isTrailingComment())
941  Previous = Previous->Previous;
942  if (Previous && Previous->is(tok::question))
943  State.Stack.back().QuestionColumn = State.Column;
944  }
945  if (!Current.opensScope() && !Current.closesScope() &&
946  !Current.is(TT_PointerOrReference))
947  State.LowestLevelOnLine =
948  std::min(State.LowestLevelOnLine, Current.NestingLevel);
949  if (Current.isMemberAccess())
950  State.Stack.back().StartOfFunctionCall =
951  !Current.NextOperator ? 0 : State.Column;
952  if (Current.is(TT_SelectorName)) {
953  State.Stack.back().ObjCSelectorNameFound = true;
954  if (Style.IndentWrappedFunctionNames) {
955  State.Stack.back().Indent =
956  State.FirstIndent + Style.ContinuationIndentWidth;
957  }
958  }
959  if (Current.is(TT_CtorInitializerColon) &&
961  // Indent 2 from the column, so:
962  // SomeClass::SomeClass()
963  // : First(...), ...
964  // Next(...)
965  // ^ line up here.
966  State.Stack.back().Indent =
967  State.Column +
969  ? 0
970  : 2);
971  State.Stack.back().NestedBlockIndent = State.Stack.back().Indent;
973  State.Stack.back().AvoidBinPacking = true;
974  State.Stack.back().BreakBeforeParameter = false;
975  }
976  if (Current.is(TT_CtorInitializerColon) &&
978  State.Stack.back().Indent =
980  State.Stack.back().NestedBlockIndent = State.Stack.back().Indent;
982  State.Stack.back().AvoidBinPacking = true;
983  }
984  if (Current.is(TT_InheritanceColon))
985  State.Stack.back().Indent =
986  State.FirstIndent + Style.ContinuationIndentWidth;
987  if (Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline)
988  State.Stack.back().NestedBlockIndent =
989  State.Column + Current.ColumnWidth + 1;
990  if (Current.isOneOf(TT_LambdaLSquare, TT_LambdaArrow))
991  State.Stack.back().LastSpace = State.Column;
992 
993  // Insert scopes created by fake parenthesis.
994  const FormatToken *Previous = Current.getPreviousNonComment();
995 
996  // Add special behavior to support a format commonly used for JavaScript
997  // closures:
998  // SomeFunction(function() {
999  // foo();
1000  // bar();
1001  // }, a, b, c);
1002  if (Current.isNot(tok::comment) && Previous &&
1003  Previous->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&
1004  !Previous->is(TT_DictLiteral) && State.Stack.size() > 1) {
1005  if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline)
1006  for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i)
1007  State.Stack[i].NoLineBreak = true;
1008  State.Stack[State.Stack.size() - 2].NestedBlockInlined = false;
1009  }
1010  if (Previous &&
1011  (Previous->isOneOf(tok::l_paren, tok::comma, tok::colon) ||
1012  Previous->isOneOf(TT_BinaryOperator, TT_ConditionalExpr)) &&
1013  !Previous->isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)) {
1014  State.Stack.back().NestedBlockInlined =
1015  !Newline &&
1016  (Previous->isNot(tok::l_paren) || Previous->ParameterCount > 1);
1017  }
1018 
1019  moveStatePastFakeLParens(State, Newline);
1020  moveStatePastScopeCloser(State);
1021  bool AllowBreak = !State.Stack.back().NoLineBreak &&
1022  !State.Stack.back().NoLineBreakInOperand;
1023  moveStatePastScopeOpener(State, Newline);
1024  moveStatePastFakeRParens(State);
1025 
1026  if (Current.is(TT_ObjCStringLiteral) && State.StartOfStringLiteral == 0)
1027  State.StartOfStringLiteral = State.Column + 1;
1028  else if (Current.isStringLiteral() && State.StartOfStringLiteral == 0)
1029  State.StartOfStringLiteral = State.Column;
1030  else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) &&
1031  !Current.isStringLiteral())
1032  State.StartOfStringLiteral = 0;
1033 
1034  State.Column += Current.ColumnWidth;
1035  State.NextToken = State.NextToken->Next;
1036 
1037  unsigned Penalty =
1038  handleEndOfLine(Current, State, DryRun, AllowBreak);
1039 
1040  if (Current.Role)
1041  Current.Role->formatFromToken(State, this, DryRun);
1042  // If the previous has a special role, let it consume tokens as appropriate.
1043  // It is necessary to start at the previous token for the only implemented
1044  // role (comma separated list). That way, the decision whether or not to break
1045  // after the "{" is already done and both options are tried and evaluated.
1046  // FIXME: This is ugly, find a better way.
1047  if (Previous && Previous->Role)
1048  Penalty += Previous->Role->formatAfterToken(State, this, DryRun);
1049 
1050  return Penalty;
1051 }
1052 
1053 void ContinuationIndenter::moveStatePastFakeLParens(LineState &State,
1054  bool Newline) {
1055  const FormatToken &Current = *State.NextToken;
1056  const FormatToken *Previous = Current.getPreviousNonComment();
1057 
1058  // Don't add extra indentation for the first fake parenthesis after
1059  // 'return', assignments or opening <({[. The indentation for these cases
1060  // is special cased.
1061  bool SkipFirstExtraIndent =
1062  (Previous && (Previous->opensScope() ||
1063  Previous->isOneOf(tok::semi, tok::kw_return) ||
1064  (Previous->getPrecedence() == prec::Assignment &&
1065  Style.AlignOperands) ||
1066  Previous->is(TT_ObjCMethodExpr)));
1068  I = Current.FakeLParens.rbegin(),
1069  E = Current.FakeLParens.rend();
1070  I != E; ++I) {
1071  ParenState NewParenState = State.Stack.back();
1072  NewParenState.ContainsLineBreak = false;
1073  NewParenState.LastOperatorWrapped = true;
1074  NewParenState.NoLineBreak =
1075  NewParenState.NoLineBreak || State.Stack.back().NoLineBreakInOperand;
1076 
1077  // Don't propagate AvoidBinPacking into subexpressions of arg/param lists.
1078  if (*I > prec::Comma)
1079  NewParenState.AvoidBinPacking = false;
1080 
1081  // Indent from 'LastSpace' unless these are fake parentheses encapsulating
1082  // a builder type call after 'return' or, if the alignment after opening
1083  // brackets is disabled.
1084  if (!Current.isTrailingComment() &&
1085  (Style.AlignOperands || *I < prec::Assignment) &&
1086  (!Previous || Previous->isNot(tok::kw_return) ||
1087  (Style.Language != FormatStyle::LK_Java && *I > 0)) &&
1089  *I != prec::Comma || Current.NestingLevel == 0))
1090  NewParenState.Indent =
1091  std::max(std::max(State.Column, NewParenState.Indent),
1092  State.Stack.back().LastSpace);
1093 
1094  // Do not indent relative to the fake parentheses inserted for "." or "->".
1095  // This is a special case to make the following to statements consistent:
1096  // OuterFunction(InnerFunctionCall( // break
1097  // ParameterToInnerFunction));
1098  // OuterFunction(SomeObject.InnerFunctionCall( // break
1099  // ParameterToInnerFunction));
1100  if (*I > prec::Unknown)
1101  NewParenState.LastSpace = std::max(NewParenState.LastSpace, State.Column);
1102  if (*I != prec::Conditional && !Current.is(TT_UnaryOperator) &&
1104  NewParenState.StartOfFunctionCall = State.Column;
1105 
1106  // Always indent conditional expressions. Never indent expression where
1107  // the 'operator' is ',', ';' or an assignment (i.e. *I <=
1108  // prec::Assignment) as those have different indentation rules. Indent
1109  // other expression, unless the indentation needs to be skipped.
1110  if (*I == prec::Conditional ||
1111  (!SkipFirstExtraIndent && *I > prec::Assignment &&
1112  !Current.isTrailingComment()))
1113  NewParenState.Indent += Style.ContinuationIndentWidth;
1114  if ((Previous && !Previous->opensScope()) || *I != prec::Comma)
1115  NewParenState.BreakBeforeParameter = false;
1116  State.Stack.push_back(NewParenState);
1117  SkipFirstExtraIndent = false;
1118  }
1119 }
1120 
1121 void ContinuationIndenter::moveStatePastFakeRParens(LineState &State) {
1122  for (unsigned i = 0, e = State.NextToken->FakeRParens; i != e; ++i) {
1123  unsigned VariablePos = State.Stack.back().VariablePos;
1124  if (State.Stack.size() == 1) {
1125  // Do not pop the last element.
1126  break;
1127  }
1128  State.Stack.pop_back();
1129  State.Stack.back().VariablePos = VariablePos;
1130  }
1131 }
1132 
1133 void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
1134  bool Newline) {
1135  const FormatToken &Current = *State.NextToken;
1136  if (!Current.opensScope())
1137  return;
1138 
1139  if (Current.MatchingParen && Current.BlockKind == BK_Block) {
1140  moveStateToNewBlock(State);
1141  return;
1142  }
1143 
1144  unsigned NewIndent;
1145  unsigned LastSpace = State.Stack.back().LastSpace;
1146  bool AvoidBinPacking;
1147  bool BreakBeforeParameter = false;
1148  unsigned NestedBlockIndent = std::max(State.Stack.back().StartOfFunctionCall,
1149  State.Stack.back().NestedBlockIndent);
1150  if (Current.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
1151  opensProtoMessageField(Current, Style)) {
1152  if (Current.opensBlockOrBlockTypeList(Style)) {
1153  NewIndent = Style.IndentWidth +
1154  std::min(State.Column, State.Stack.back().NestedBlockIndent);
1155  } else {
1156  NewIndent = State.Stack.back().LastSpace + Style.ContinuationIndentWidth;
1157  }
1158  const FormatToken *NextNoComment = Current.getNextNonComment();
1159  bool EndsInComma = Current.MatchingParen &&
1160  Current.MatchingParen->Previous &&
1161  Current.MatchingParen->Previous->is(tok::comma);
1162  AvoidBinPacking = EndsInComma || Current.is(TT_DictLiteral) ||
1163  Style.Language == FormatStyle::LK_Proto ||
1165  !Style.BinPackArguments ||
1166  (NextNoComment &&
1167  NextNoComment->isOneOf(TT_DesignatedInitializerPeriod,
1168  TT_DesignatedInitializerLSquare));
1169  BreakBeforeParameter = EndsInComma;
1170  if (Current.ParameterCount > 1)
1171  NestedBlockIndent = std::max(NestedBlockIndent, State.Column + 1);
1172  } else {
1173  NewIndent = Style.ContinuationIndentWidth +
1174  std::max(State.Stack.back().LastSpace,
1175  State.Stack.back().StartOfFunctionCall);
1176 
1177  // Ensure that different different brackets force relative alignment, e.g.:
1178  // void SomeFunction(vector< // break
1179  // int> v);
1180  // FIXME: We likely want to do this for more combinations of brackets.
1181  // Verify that it is wanted for ObjC, too.
1182  if (Current.is(tok::less) && Current.ParentBracket == tok::l_paren) {
1183  NewIndent = std::max(NewIndent, State.Stack.back().Indent);
1184  LastSpace = std::max(LastSpace, State.Stack.back().Indent);
1185  }
1186 
1187  bool EndsInComma =
1188  Current.MatchingParen &&
1189  Current.MatchingParen->getPreviousNonComment() &&
1190  Current.MatchingParen->getPreviousNonComment()->is(tok::comma);
1191 
1192  AvoidBinPacking =
1193  (Style.Language == FormatStyle::LK_JavaScript && EndsInComma) ||
1194  (State.Line->MustBeDeclaration && !Style.BinPackParameters) ||
1195  (!State.Line->MustBeDeclaration && !Style.BinPackArguments) ||
1197  (Current.PackingKind == PPK_OnePerLine ||
1198  (!BinPackInconclusiveFunctions &&
1199  Current.PackingKind == PPK_Inconclusive)));
1200 
1201  if (Current.is(TT_ObjCMethodExpr) && Current.MatchingParen) {
1202  if (Style.ColumnLimit) {
1203  // If this '[' opens an ObjC call, determine whether all parameters fit
1204  // into one line and put one per line if they don't.
1205  if (getLengthToMatchingParen(Current) + State.Column >
1206  getColumnLimit(State))
1207  BreakBeforeParameter = true;
1208  } else {
1209  // For ColumnLimit = 0, we have to figure out whether there is or has to
1210  // be a line break within this call.
1211  for (const FormatToken *Tok = &Current;
1212  Tok && Tok != Current.MatchingParen; Tok = Tok->Next) {
1213  if (Tok->MustBreakBefore ||
1214  (Tok->CanBreakBefore && Tok->NewlinesBefore > 0)) {
1215  BreakBeforeParameter = true;
1216  break;
1217  }
1218  }
1219  }
1220  }
1221 
1222  if (Style.Language == FormatStyle::LK_JavaScript && EndsInComma)
1223  BreakBeforeParameter = true;
1224  }
1225  // Generally inherit NoLineBreak from the current scope to nested scope.
1226  // However, don't do this for non-empty nested blocks, dict literals and
1227  // array literals as these follow different indentation rules.
1228  bool NoLineBreak =
1229  Current.Children.empty() &&
1230  !Current.isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) &&
1231  (State.Stack.back().NoLineBreak ||
1232  State.Stack.back().NoLineBreakInOperand ||
1233  (Current.is(TT_TemplateOpener) &&
1234  State.Stack.back().ContainsUnwrappedBuilder));
1235  State.Stack.push_back(
1236  ParenState(NewIndent, LastSpace, AvoidBinPacking, NoLineBreak));
1237  State.Stack.back().NestedBlockIndent = NestedBlockIndent;
1238  State.Stack.back().BreakBeforeParameter = BreakBeforeParameter;
1239  State.Stack.back().HasMultipleNestedBlocks = Current.BlockParameterCount > 1;
1240 }
1241 
1242 void ContinuationIndenter::moveStatePastScopeCloser(LineState &State) {
1243  const FormatToken &Current = *State.NextToken;
1244  if (!Current.closesScope())
1245  return;
1246 
1247  // If we encounter a closing ), ], } or >, we can remove a level from our
1248  // stacks.
1249  if (State.Stack.size() > 1 &&
1250  (Current.isOneOf(tok::r_paren, tok::r_square, TT_TemplateString) ||
1251  (Current.is(tok::r_brace) && State.NextToken != State.Line->First) ||
1252  State.NextToken->is(TT_TemplateCloser)))
1253  State.Stack.pop_back();
1254 
1255  if (Current.is(tok::r_square)) {
1256  // If this ends the array subscript expr, reset the corresponding value.
1257  const FormatToken *NextNonComment = Current.getNextNonComment();
1258  if (NextNonComment && NextNonComment->isNot(tok::l_square))
1259  State.Stack.back().StartOfArraySubscripts = 0;
1260  }
1261 }
1262 
1263 void ContinuationIndenter::moveStateToNewBlock(LineState &State) {
1264  unsigned NestedBlockIndent = State.Stack.back().NestedBlockIndent;
1265  // ObjC block sometimes follow special indentation rules.
1266  unsigned NewIndent =
1267  NestedBlockIndent + (State.NextToken->is(TT_ObjCBlockLBrace)
1268  ? Style.ObjCBlockIndentWidth
1269  : Style.IndentWidth);
1270  State.Stack.push_back(ParenState(NewIndent, State.Stack.back().LastSpace,
1271  /*AvoidBinPacking=*/true,
1272  /*NoLineBreak=*/false));
1273  State.Stack.back().NestedBlockIndent = NestedBlockIndent;
1274  State.Stack.back().BreakBeforeParameter = true;
1275 }
1276 
1277 static unsigned getLastLineEndColumn(StringRef Text, unsigned StartColumn,
1278  unsigned TabWidth,
1279  encoding::Encoding Encoding) {
1280  size_t LastNewlinePos = Text.find_last_of("\n");
1281  if (LastNewlinePos == StringRef::npos) {
1282  return StartColumn +
1283  encoding::columnWidthWithTabs(Text, StartColumn, TabWidth, Encoding);
1284  } else {
1285  return encoding::columnWidthWithTabs(Text.substr(LastNewlinePos),
1286  /*StartColumn=*/0, TabWidth, Encoding);
1287  }
1288 }
1289 
1290 unsigned ContinuationIndenter::reformatRawStringLiteral(
1291  const FormatToken &Current, LineState &State,
1292  const FormatStyle &RawStringStyle, bool DryRun) {
1293  unsigned StartColumn = State.Column - Current.ColumnWidth;
1294  auto Delimiter = *getRawStringDelimiter(Current.TokenText);
1295  // The text of a raw string is between the leading 'R"delimiter(' and the
1296  // trailing 'delimiter)"'.
1297  unsigned PrefixSize = 3 + Delimiter.size();
1298  unsigned SuffixSize = 2 + Delimiter.size();
1299 
1300  // The first start column is the column the raw text starts.
1301  unsigned FirstStartColumn = StartColumn + PrefixSize;
1302 
1303  // The next start column is the intended indentation a line break inside
1304  // the raw string at level 0. It is determined by the following rules:
1305  // - if the content starts on newline, it is one level more than the current
1306  // indent, and
1307  // - if the content does not start on a newline, it is the first start
1308  // column.
1309  // These rules have the advantage that the formatted content both does not
1310  // violate the rectangle rule and visually flows within the surrounding
1311  // source.
1312  bool ContentStartsOnNewline = Current.TokenText[PrefixSize] == '\n';
1313  unsigned NextStartColumn = ContentStartsOnNewline
1314  ? State.Stack.back().Indent + Style.IndentWidth
1315  : FirstStartColumn;
1316 
1317  // The last start column is the column the raw string suffix starts if it is
1318  // put on a newline.
1319  // The last start column is the intended indentation of the raw string postfix
1320  // if it is put on a newline. It is determined by the following rules:
1321  // - if the raw string prefix starts on a newline, it is the column where
1322  // that raw string prefix starts, and
1323  // - if the raw string prefix does not start on a newline, it is the current
1324  // indent.
1325  unsigned LastStartColumn = Current.NewlinesBefore
1326  ? FirstStartColumn - PrefixSize
1327  : State.Stack.back().Indent;
1328 
1329  std::string RawText =
1330  Current.TokenText.substr(PrefixSize).drop_back(SuffixSize);
1331 
1332  std::pair<tooling::Replacements, unsigned> Fixes = internal::reformat(
1333  RawStringStyle, RawText, {tooling::Range(0, RawText.size())},
1334  FirstStartColumn, NextStartColumn, LastStartColumn, "<stdin>",
1335  /*Status=*/nullptr);
1336 
1337  auto NewCode = applyAllReplacements(RawText, Fixes.first);
1338  tooling::Replacements NoFixes;
1339  if (!NewCode) {
1340  State.Column += Current.ColumnWidth;
1341  return 0;
1342  }
1343  if (!DryRun) {
1344  SourceLocation OriginLoc =
1345  Current.Tok.getLocation().getLocWithOffset(PrefixSize);
1346  for (const tooling::Replacement &Fix : Fixes.first) {
1347  auto Err = Whitespaces.addReplacement(tooling::Replacement(
1348  SourceMgr, OriginLoc.getLocWithOffset(Fix.getOffset()),
1349  Fix.getLength(), Fix.getReplacementText()));
1350  if (Err) {
1351  llvm::errs() << "Failed to reformat raw string: "
1352  << llvm::toString(std::move(Err)) << "\n";
1353  }
1354  }
1355  }
1356  unsigned RawLastLineEndColumn = getLastLineEndColumn(
1357  *NewCode, FirstStartColumn, Style.TabWidth, Encoding);
1358  State.Column = RawLastLineEndColumn + SuffixSize;
1359  return Fixes.second;
1360 }
1361 
1362 unsigned ContinuationIndenter::addMultilineToken(const FormatToken &Current,
1363  LineState &State) {
1364  // Break before further function parameters on all levels.
1365  for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
1366  State.Stack[i].BreakBeforeParameter = true;
1367 
1368  unsigned ColumnsUsed = State.Column;
1369  // We can only affect layout of the first and the last line, so the penalty
1370  // for all other lines is constant, and we ignore it.
1371  State.Column = Current.LastLineColumnWidth;
1372 
1373  if (ColumnsUsed > getColumnLimit(State))
1374  return Style.PenaltyExcessCharacter * (ColumnsUsed - getColumnLimit(State));
1375  return 0;
1376 }
1377 
1378 unsigned ContinuationIndenter::handleEndOfLine(const FormatToken &Current,
1379  LineState &State, bool DryRun,
1380  bool AllowBreak) {
1381  unsigned Penalty = 0;
1382  // Compute the raw string style to use in case this is a raw string literal
1383  // that can be reformatted.
1384  auto RawStringStyle = getRawStringStyle(Current, State);
1385  if (RawStringStyle) {
1386  Penalty = reformatRawStringLiteral(Current, State, *RawStringStyle, DryRun);
1387  } else if (Current.IsMultiline && Current.isNot(TT_BlockComment)) {
1388  // Don't break multi-line tokens other than block comments and raw string
1389  // literals. Instead, just update the state.
1390  Penalty = addMultilineToken(Current, State);
1391  } else if (State.Line->Type != LT_ImportStatement) {
1392  // We generally don't break import statements.
1393  Penalty = breakProtrudingToken(Current, State, AllowBreak, DryRun);
1394  }
1395  if (State.Column > getColumnLimit(State)) {
1396  unsigned ExcessCharacters = State.Column - getColumnLimit(State);
1397  Penalty += Style.PenaltyExcessCharacter * ExcessCharacters;
1398  }
1399  return Penalty;
1400 }
1401 
1403 ContinuationIndenter::getRawStringStyle(const FormatToken &Current,
1404  const LineState &State) {
1405  if (!Current.isStringLiteral())
1406  return None;
1407  auto Delimiter = getRawStringDelimiter(Current.TokenText);
1408  if (!Delimiter)
1409  return None;
1410  auto RawStringStyle = RawStringFormats.get(*Delimiter);
1411  if (!RawStringStyle)
1412  return None;
1413  RawStringStyle->ColumnLimit = getColumnLimit(State);
1414  return RawStringStyle;
1415 }
1416 
1417 std::unique_ptr<BreakableToken> ContinuationIndenter::createBreakableToken(
1418  const FormatToken &Current, LineState &State, bool AllowBreak) {
1419  unsigned StartColumn = State.Column - Current.ColumnWidth;
1420  if (Current.isStringLiteral()) {
1421  // FIXME: String literal breaking is currently disabled for Java and JS, as
1422  // it requires strings to be merged using "+" which we don't support.
1423  if (Style.Language == FormatStyle::LK_Java ||
1425  !Style.BreakStringLiterals ||
1426  !AllowBreak)
1427  return nullptr;
1428 
1429  // Don't break string literals inside preprocessor directives (except for
1430  // #define directives, as their contents are stored in separate lines and
1431  // are not affected by this check).
1432  // This way we avoid breaking code with line directives and unknown
1433  // preprocessor directives that contain long string literals.
1434  if (State.Line->Type == LT_PreprocessorDirective)
1435  return nullptr;
1436  // Exempts unterminated string literals from line breaking. The user will
1437  // likely want to terminate the string before any line breaking is done.
1438  if (Current.IsUnterminatedLiteral)
1439  return nullptr;
1440 
1441  StringRef Text = Current.TokenText;
1442  StringRef Prefix;
1443  StringRef Postfix;
1444  // FIXME: Handle whitespace between '_T', '(', '"..."', and ')'.
1445  // FIXME: Store Prefix and Suffix (or PrefixLength and SuffixLength to
1446  // reduce the overhead) for each FormatToken, which is a string, so that we
1447  // don't run multiple checks here on the hot path.
1448  if ((Text.endswith(Postfix = "\"") &&
1449  (Text.startswith(Prefix = "@\"") || Text.startswith(Prefix = "\"") ||
1450  Text.startswith(Prefix = "u\"") || Text.startswith(Prefix = "U\"") ||
1451  Text.startswith(Prefix = "u8\"") ||
1452  Text.startswith(Prefix = "L\""))) ||
1453  (Text.startswith(Prefix = "_T(\"") && Text.endswith(Postfix = "\")"))) {
1454  return llvm::make_unique<BreakableStringLiteral>(
1455  Current, StartColumn, Prefix, Postfix, State.Line->InPPDirective,
1456  Encoding, Style);
1457  }
1458  } else if (Current.is(TT_BlockComment)) {
1459  if (!Style.ReflowComments ||
1460  // If a comment token switches formatting, like
1461  // /* clang-format on */, we don't want to break it further,
1462  // but we may still want to adjust its indentation.
1463  switchesFormatting(Current)) {
1464  return nullptr;
1465  }
1466  return llvm::make_unique<BreakableBlockComment>(
1467  Current, StartColumn, Current.OriginalColumn, !Current.Previous,
1468  State.Line->InPPDirective, Encoding, Style);
1469  } else if (Current.is(TT_LineComment) &&
1470  (Current.Previous == nullptr ||
1471  Current.Previous->isNot(TT_ImplicitStringLiteral))) {
1472  if (!Style.ReflowComments ||
1473  CommentPragmasRegex.match(Current.TokenText.substr(2)) ||
1474  switchesFormatting(Current))
1475  return nullptr;
1476  return llvm::make_unique<BreakableLineCommentSection>(
1477  Current, StartColumn, Current.OriginalColumn, !Current.Previous,
1478  /*InPPDirective=*/false, Encoding, Style);
1479  }
1480  return nullptr;
1481 }
1482 
1483 unsigned ContinuationIndenter::breakProtrudingToken(const FormatToken &Current,
1484  LineState &State,
1485  bool AllowBreak,
1486  bool DryRun) {
1487  std::unique_ptr<BreakableToken> Token =
1488  createBreakableToken(Current, State, AllowBreak);
1489  if (!Token)
1490  return 0;
1491  unsigned ColumnLimit = getColumnLimit(State);
1492  unsigned StartColumn = State.Column - Current.ColumnWidth;
1493  if (Current.is(TT_LineComment)) {
1494  // We don't insert backslashes when breaking line comments.
1495  ColumnLimit = Style.ColumnLimit;
1496  }
1497  if (Current.UnbreakableTailLength >= ColumnLimit)
1498  return 0;
1499 
1500  unsigned NewBreakPenalty = Current.isStringLiteral()
1501  ? Style.PenaltyBreakString
1502  : Style.PenaltyBreakComment;
1503  unsigned RemainingSpace = ColumnLimit - Current.UnbreakableTailLength;
1504  bool BreakInserted = Token->introducesBreakBeforeToken();
1505  // Store whether we inserted a new line break at the end of the previous
1506  // logical line.
1507  bool NewBreakBefore = false;
1508  // We use a conservative reflowing strategy. Reflow starts after a line is
1509  // broken or the corresponding whitespace compressed. Reflow ends as soon as a
1510  // line that doesn't get reflown with the previous line is reached.
1511  bool ReflowInProgress = false;
1512  unsigned Penalty = 0;
1513  unsigned RemainingTokenColumns = 0;
1514  unsigned TailOffset = 0;
1515  DEBUG(llvm::dbgs() << "Breaking protruding token at column " << StartColumn
1516  << ".\n");
1517  for (unsigned LineIndex = 0, EndIndex = Token->getLineCount();
1518  LineIndex != EndIndex; ++LineIndex) {
1519  DEBUG(llvm::dbgs() << " Line: " << LineIndex
1520  << " (Reflow: " << ReflowInProgress << ")\n");
1521  BreakableToken::Split SplitBefore(StringRef::npos, 0);
1522  if (ReflowInProgress) {
1523  SplitBefore = Token->getSplitBefore(LineIndex, RemainingTokenColumns,
1524  RemainingSpace, CommentPragmasRegex);
1525  }
1526  ReflowInProgress = SplitBefore.first != StringRef::npos;
1527  DEBUG({
1528  if (ReflowInProgress)
1529  llvm::dbgs() << " Reflowing.\n";
1530  });
1531  TailOffset =
1532  ReflowInProgress ? (SplitBefore.first + SplitBefore.second) : 0;
1533  // If we found a reflow split and have added a new break before this line,
1534  // we are going to remove the line break at the start of the next logical
1535  // line.
1536  // For example, here we'll add a new line break after 'text', and
1537  // subsequently delete the line break between 'that' and 'reflows'.
1538  // // some text that
1539  // // reflows
1540  // ->
1541  // // some text
1542  // // that reflows
1543  // When adding the line break, we also added the penalty for it, so we need
1544  // to subtract that penalty again when we remove the line break due to
1545  // reflowing.
1546  if (ReflowInProgress && NewBreakBefore) {
1547  assert(Penalty >= NewBreakPenalty);
1548  Penalty -= NewBreakPenalty;
1549  }
1550  NewBreakBefore = false;
1551  if (!DryRun)
1552  Token->replaceWhitespaceBefore(LineIndex, RemainingTokenColumns,
1553  RemainingSpace, SplitBefore, Whitespaces);
1554  RemainingTokenColumns = Token->getLineLengthAfterSplitBefore(
1555  LineIndex, TailOffset, RemainingTokenColumns, ColumnLimit, SplitBefore);
1556  while (RemainingTokenColumns > RemainingSpace) {
1557  DEBUG(llvm::dbgs() << " Over limit, need: " << RemainingTokenColumns
1558  << ", space: " << RemainingSpace << "\n");
1559  BreakableToken::Split Split = Token->getSplit(
1560  LineIndex, TailOffset, ColumnLimit, CommentPragmasRegex);
1561  if (Split.first == StringRef::npos) {
1562  // The last line's penalty is handled in addNextStateToQueue().
1563  if (LineIndex < EndIndex - 1)
1564  Penalty += Style.PenaltyExcessCharacter *
1565  (RemainingTokenColumns - RemainingSpace);
1566  DEBUG(llvm::dbgs() << " No break opportunity.\n");
1567  break;
1568  }
1569  assert(Split.first != 0);
1570 
1571  // Check if compressing the whitespace range will bring the line length
1572  // under the limit. If that is the case, we perform whitespace compression
1573  // instead of inserting a line break.
1574  unsigned RemainingTokenColumnsAfterCompression =
1575  Token->getLineLengthAfterCompression(RemainingTokenColumns, Split);
1576  if (RemainingTokenColumnsAfterCompression <= RemainingSpace) {
1577  RemainingTokenColumns = RemainingTokenColumnsAfterCompression;
1578  ReflowInProgress = true;
1579  if (!DryRun)
1580  Token->compressWhitespace(LineIndex, TailOffset, Split, Whitespaces);
1581  DEBUG(llvm::dbgs() << " Compressing below limit.\n");
1582  break;
1583  }
1584 
1585  // Compute both the penalties for:
1586  // - not breaking, and leaving excess characters
1587  // - adding a new line break
1588  assert(RemainingTokenColumnsAfterCompression > RemainingSpace);
1589  unsigned ExcessCharactersPenalty =
1590  (RemainingTokenColumnsAfterCompression - RemainingSpace) *
1591  Style.PenaltyExcessCharacter;
1592 
1593  unsigned BreakPenalty = NewBreakPenalty;
1594  unsigned ColumnsUsed =
1595  Token->getLineLengthAfterSplit(LineIndex, TailOffset, Split.first);
1596  if (ColumnsUsed > ColumnLimit)
1597  BreakPenalty +=
1598  Style.PenaltyExcessCharacter * (ColumnsUsed - ColumnLimit);
1599 
1600  DEBUG(llvm::dbgs() << " Penalty excess: " << ExcessCharactersPenalty
1601  << "\n break : " << BreakPenalty << "\n");
1602  // Only continue to add the line break if the penalty of the excess
1603  // characters is larger than the penalty of the line break.
1604  // FIXME: This does not take into account when we can later remove the
1605  // line break again due to a reflow.
1606  if (ExcessCharactersPenalty < BreakPenalty) {
1607  if (!DryRun)
1608  Token->compressWhitespace(LineIndex, TailOffset, Split, Whitespaces);
1609  // Do not set ReflowInProgress: we do not have any space left to
1610  // reflow into.
1611  Penalty += ExcessCharactersPenalty;
1612  break;
1613  }
1614 
1615  unsigned NewRemainingTokenColumns = Token->getLineLengthAfterSplit(
1616  LineIndex, TailOffset + Split.first + Split.second, StringRef::npos);
1617 
1618  // When breaking before a tab character, it may be moved by a few columns,
1619  // but will still be expanded to the next tab stop, so we don't save any
1620  // columns.
1621  if (NewRemainingTokenColumns == RemainingTokenColumns)
1622  // FIXME: Do we need to adjust the penalty?
1623  break;
1624  assert(NewRemainingTokenColumns < RemainingTokenColumns);
1625 
1626  if (!DryRun)
1627  Token->insertBreak(LineIndex, TailOffset, Split, Whitespaces);
1628 
1629  Penalty += BreakPenalty;
1630  TailOffset += Split.first + Split.second;
1631  RemainingTokenColumns = NewRemainingTokenColumns;
1632  ReflowInProgress = true;
1633  BreakInserted = true;
1634  NewBreakBefore = true;
1635  }
1636  }
1637 
1638  BreakableToken::Split SplitAfterLastLine =
1639  Token->getSplitAfterLastLine(TailOffset, ColumnLimit);
1640  if (SplitAfterLastLine.first != StringRef::npos) {
1641  DEBUG(llvm::dbgs() << "Replacing whitespace after last line.\n");
1642  if (!DryRun)
1643  Token->replaceWhitespaceAfterLastLine(TailOffset, SplitAfterLastLine,
1644  Whitespaces);
1645  RemainingTokenColumns = Token->getLineLengthAfterSplitAfterLastLine(
1646  TailOffset, SplitAfterLastLine);
1647  }
1648 
1649  State.Column = RemainingTokenColumns;
1650 
1651  if (BreakInserted) {
1652  // If we break the token inside a parameter list, we need to break before
1653  // the next parameter on all levels, so that the next parameter is clearly
1654  // visible. Line comments already introduce a break.
1655  if (Current.isNot(TT_LineComment)) {
1656  for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
1657  State.Stack[i].BreakBeforeParameter = true;
1658  }
1659 
1660  if (Current.is(TT_BlockComment))
1661  State.NoContinuation = true;
1662 
1663  State.Stack.back().LastSpace = StartColumn;
1664  }
1665 
1666  Token->updateNextToken(State);
1667 
1668  return Penalty;
1669 }
1670 
1671 unsigned ContinuationIndenter::getColumnLimit(const LineState &State) const {
1672  // In preprocessor directives reserve two chars for trailing " \"
1673  return Style.ColumnLimit - (State.Line->InPPDirective ? 2 : 0);
1674 }
1675 
1676 bool ContinuationIndenter::nextIsMultilineString(const LineState &State) {
1677  const FormatToken &Current = *State.NextToken;
1678  if (!Current.isStringLiteral() || Current.is(TT_ImplicitStringLiteral))
1679  return false;
1680  // We never consider raw string literals "multiline" for the purpose of
1681  // AlwaysBreakBeforeMultilineStrings implementation as they are special-cased
1682  // (see TokenAnnotator::mustBreakBefore().
1683  if (Current.TokenText.startswith("R\""))
1684  return false;
1685  if (Current.IsMultiline)
1686  return true;
1687  if (Current.getNextNonComment() &&
1688  Current.getNextNonComment()->isStringLiteral())
1689  return true; // Implicit concatenation.
1690  if (Style.ColumnLimit != 0 &&
1691  State.Column + Current.ColumnWidth + Current.UnbreakableTailLength >
1692  Style.ColumnLimit)
1693  return true; // String will be split.
1694  return false;
1695 }
1696 
1697 } // namespace format
1698 } // namespace clang
static bool startsSegmentOfBuilderTypeCall(const FormatToken &Tok)
bool endsSequence(A K1, Ts... Tokens) const
true if this token ends a sequence with the given tokens in order, following the Previous pointers...
Definition: FormatToken.h:325
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
unsigned LowestLevelOnLine
The lowest NestingLevel on the current line.
unsigned NestingLevel
The nesting level of this token, i.e.
Definition: FormatToken.h:228
bool switchesFormatting(const FormatToken &Token)
Checks if Token switches formatting, like /* clang-format off.
bool AlwaysBreakBeforeMultilineStrings
If true, always break before multiline string literals.
Definition: Format.h:350
Token Tok
The Token.
Definition: FormatToken.h:124
bool ContainsLineBreak
true if this ParenState already contains a line-break.
Should be used for Protocol Buffers (https://developers.google.com/protocol-buffers/).
Definition: Format.h:1175
Defines the SourceManager interface.
unsigned IndentWidth
The number of columns to use for indentation.
Definition: Format.h:1092
std::unique_ptr< TokenRole > Role
A token can have a special role that can carry extra information about the token&#39;s formatting...
Definition: FormatToken.h:204
Break constructor initializers before the colon and commas, and align the commas with the colon...
Definition: Format.h:810
unsigned OriginalColumn
The original 0-based column of this token, including expanded tabs.
Definition: FormatToken.h:215
bool isMemberAccess() const
Returns true if this is a "." or "->" accessing a member.
Definition: FormatToken.h:367
Declares BreakableToken, BreakableStringLiteral, BreakableComment, BreakableBlockComment and Breakabl...
StringRef P
static unsigned getLastLineEndColumn(StringRef Text, unsigned StartColumn, unsigned TabWidth, encoding::Encoding Encoding)
const FormatToken * getNextNonComment() const
Returns the next token ignoring comments.
Definition: FormatToken.h:456
Maintains a set of replacements that are conflict-free.
Definition: Replacement.h:205
bool IsMultiline
Whether the token text contains newlines (escaped or not).
Definition: FormatToken.h:153
unsigned PenaltyBreakFirstLessLess
The penalty for breaking before the first <<.
Definition: Format.h:1296
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:256
unsigned TotalLength
The total length of the unwrapped line up to and including this token.
Definition: FormatToken.h:211
bool isBinaryOperator() const
Definition: FormatToken.h:389
PPDirectiveIndentStyle IndentPPDirectives
The preprocessor directive indenting style to use.
Definition: Format.h:1079
unsigned NewlinesBefore
The number of newlines immediately before the Token.
Definition: FormatToken.h:130
FormatToken * Next
The next token in the unwrapped line.
Definition: FormatToken.h:283
Break after operators.
Definition: Format.h:406
bool isLiteral() const
Return true if this is a "literal", like a numeric constant, string, etc.
Definition: Token.h:113
Break constructor initializers before the colon and after the commas.
Definition: Format.h:802
unsigned UnbreakableTailLength
The length of following tokens until the next natural split point, or the next token that can be brok...
Definition: FormatToken.h:219
bool closesScope() const
Returns whether Tok is )]} or a template closing >.
Definition: FormatToken.h:359
bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite)
Apply all replacements in Replaces to the Rewriter Rewrite.
unsigned SplitPenalty
Penalty for inserting a line break before this token.
Definition: FormatToken.h:234
prec::Level getPrecedence() const
Definition: FormatToken.h:443
unsigned ParameterCount
Number of parameters, if this is "(", "[" or "<".
Definition: FormatToken.h:192
unsigned FakeRParens
Insert this many fake ) after this token for correct indentation.
Definition: FormatToken.h:250
bool ExperimentalAutoDetectBinPacking
If true, clang-format detects whether function calls and definitions are formatted with one parameter...
Definition: Format.h:959
LineState State
bool CanBreakBefore
true if it is allowed to break before this token.
Definition: FormatToken.h:182
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:1168
FormatToken * Previous
The previous token in the unwrapped line.
Definition: FormatToken.h:280
bool StartsBinaryExpression
true if this token starts a binary expression, i.e.
Definition: FormatToken.h:254
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:1930
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
unsigned columnWidthWithTabs(StringRef Text, unsigned StartColumn, unsigned TabWidth, Encoding Encoding)
Returns the number of columns required to display the Text, starting from the StartColumn on a termin...
Definition: Encoding.h:62
unsigned LongestObjCSelectorName
If this is the first ObjC selector name in an ObjC method definition or call, this contains the lengt...
Definition: FormatToken.h:241
Manages the whitespaces around tokens and their replacements.
unsigned getColumnLimit(const LineState &State) const
Get the column limit for this line.
bool ConstructorInitializerAllOnOneLineOrOnePerLine
If the constructor initializers don&#39;t fit on a line, put each initializer on its own line...
Definition: Format.h:901
unsigned PenaltyBreakComment
The penalty for each line break introduced inside a comment.
Definition: Format.h:1293
unsigned OperatorIndex
Is this is an operator (or "."/"->") in a sequence of operators with the same precedence, contains the 0-based operator index.
Definition: FormatToken.h:260
unsigned SpacesRequiredBefore
The number of spaces that should be inserted before this token.
Definition: FormatToken.h:179
bool IndentWrappedFunctionNames
Indent if a function definition or declaration is wrapped after the type.
Definition: Format.h:1105
unsigned Indent
The position to which a specific parenthesis level needs to be indented.
bool isNot(T Kind) const
Definition: FormatToken.h:313
Always break after an open bracket, if the parameters don&#39;t fit on a single line, e...
Definition: Format.h:70
static unsigned getLengthToNextOperator(const FormatToken &Tok)
bool closesBlockOrBlockTypeList(const FormatStyle &Style) const
Same as opensBlockOrBlockTypeList, but for the closing token.
Definition: FormatToken.h:490
const FormatToken & Tok
ReturnTypeBreakingStyle AlwaysBreakAfterReturnType
The function declaration return type breaking style to use.
Definition: Format.h:336
unsigned BlockParameterCount
Number of parameters that are nested blocks, if this is "(", "[" or "<".
Definition: FormatToken.h:196
const AnnotatedLine * Line
The line that is being formatted.
bool BinPackArguments
If false, a function call&#39;s arguments will either be all on the same line or will have one line each...
Definition: Format.h:377
unsigned ObjCBlockIndentWidth
The number of characters to use for indentation of ObjC blocks.
Definition: Format.h:1276
bool LineContainsContinuedForLoopSection
true if this line contains a continued for-loop section.
unsigned ColumnLimit
The column limit.
Definition: Format.h:840
bool LastOperatorWrapped
True if the last binary operator on this level was wrapped to the next line.
bool BreakBeforeParameter
Break after the next comma (or all the commas in this context if AvoidBinPacking is true)...
FormatToken * getPreviousNonComment() const
Returns the previous token ignoring comments.
Definition: FormatToken.h:448
BracketAlignmentStyle AlignAfterOpenBracket
If true, horizontally aligns arguments after an open bracket.
Definition: Format.h:77
bool isOneOf(A K1, B K2) const
Definition: FormatToken.h:306
A text replacement.
Definition: Replacement.h:81
UseTabStyle UseTab
The way to use tab characters in the resulting file.
Definition: Format.h:1564
A source range independent of the SourceManager.
Definition: Replacement.h:42
FormatStyle getLLVMStyle()
Returns a format style complying with the LLVM coding standards: http://llvm.org/docs/CodingStandards...
Definition: Format.cpp:568
The current state when indenting a unwrapped line.
Break after return type automatically.
Definition: Format.h:272
WhitespaceManager class manages whitespace around tokens and their replacements.
SourceLocation End
llvm::Error addReplacement(const tooling::Replacement &Replacement)
Should be used for JavaScript.
Definition: Format.h:1170
const AnnotatedLine * Line
StateNode * Previous
ParameterPackingKind PackingKind
If this is an opening parenthesis, how are the parameters packed?
Definition: FormatToken.h:207
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:144
A wrapper around a Token storing information about the whitespace characters preceding it...
Definition: FormatToken.h:120
char __ovld __cnfn min(char x, char y)
Returns y if y < x, otherwise it returns x.
Defines and computes precedence levels for binary/ternary operators.
SourceLocation getEnd() const
bool isTrailingComment() const
Definition: FormatToken.h:394
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:141
Don&#39;t align, instead use ContinuationIndentWidth, e.g.
Definition: Format.h:63
static bool opensProtoMessageField(const FormatToken &LessTok, const FormatStyle &Style)
std::vector< ParenState > Stack
A stack keeping track of properties applying to parenthesis levels.
unsigned PenaltyBreakString
The penalty for each line break introduced inside a string literal.
Definition: Format.h:1299
bool NoLineBreak
Line breaking in this context would break a formatting rule.
unsigned PenaltyExcessCharacter
The penalty for each character outside of the column limit.
Definition: Format.h:1302
Encodes a location in the source.
bool is(tok::TokenKind Kind) const
Definition: FormatToken.h:297
Various functions to configurably format source code.
bool ReflowComments
If true, clang-format will attempt to re-flow comments.
Definition: Format.h:1377
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:177
unsigned LastSpace
The position of the last space on each level.
Break constructor initializers after the colon and commas.
Definition: Format.h:817
bool BreakBeforeTernaryOperators
If true, ternary operators will be placed after line breaks.
Definition: Format.h:792
Encapsulates keywords that are context sensitive or for languages not properly supported by Clang&#39;s l...
Definition: FormatToken.h:634
SourceRange WhitespaceRange
The range of the whitespace immediately preceding the Token.
Definition: FormatToken.h:137
unsigned ContinuationIndentWidth
Indent width for line continuations.
Definition: Format.h:915
tok::TokenKind ParentBracket
If this is a bracket ("<", "(", "[" or "{"), contains the kind of the surrounding bracket...
Definition: FormatToken.h:200
bool IgnoreStackForComparison
Ignore the stack of ParenStates for state comparison.
bool IsUnterminatedLiteral
Set to true if this token is an unterminated literal.
Definition: FormatToken.h:171
bool startsWith(Ts... Tokens) const
true if this line starts with the given tokens in order, ignoring comments.
StringRef TokenText
The raw text of the token.
Definition: FormatToken.h:168
SmallVector< prec::Level, 4 > FakeLParens
Stores the number of required fake parentheses and the corresponding operator precedence.
Definition: FormatToken.h:248
unsigned addTokenToState(LineState &State, bool Newline, bool DryRun, unsigned ExtraSpaces=0)
Appends the next token to State and updates information necessary for indentation.
unsigned getLength() const
Definition: Replacement.h:120
The FormatStyle is used to configure the formatting to follow specific guidelines.
Definition: Format.h:46
RawStringFormatStyleManager(const FormatStyle &CodeStyle)
LanguageKind Language
Language, this format style is targeted at.
Definition: Format.h:1185
unsigned getSpellingColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const
Dataflow Directional Tag Classes.
ShortFunctionStyle AllowShortFunctionsOnASingleLine
Dependent on the value, int f() { return 0; } can be put on a single line.
Definition: Format.h:239
unsigned ColumnWidth
The width of the non-whitespace parts of the token (or its first line for multi-line tokens) in colum...
Definition: FormatToken.h:146
unsigned getOffset() const
Definition: Replacement.h:119
static unsigned getLengthToMatchingParen(const FormatToken &Tok)
unsigned FirstIndent
The indent of the first token.
tok::PPKeywordKind getPPKeywordID() const
Return the preprocessor keyword ID for this identifier.
bool BreakStringLiterals
Allow breaking string literals when formatting.
Definition: Format.h:833
Merge all functions fitting on a single line.
Definition: Format.h:234
std::string toString(const til::SExpr *E)
bool canBreak(const LineState &State)
Returns true, if a line break after State is allowed.
bool AllowAllParametersOfDeclarationOnNextLine
If the function declaration doesn&#39;t fit on a line, allow putting all parameters of a function declara...
Definition: Format.h:169
bool AvoidBinPacking
Avoid bin packing, i.e.
bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language, FormatStyle *Style)
Gets a predefined style for the specified language by name.
Definition: Format.cpp:822
unsigned TabWidth
The number of columns used for tab stops.
Definition: Format.h:1548
bool BreakBeforeInheritanceComma
If true, in the class inheritance expression clang-format will break before : and ...
Definition: Format.h:860
bool mustBreak(const LineState &State)
Returns true, if a line break after State is mandatory.
ContinuationIndenter(const FormatStyle &Style, const AdditionalKeywords &Keywords, const SourceManager &SourceMgr, WhitespaceManager &Whitespaces, encoding::Encoding Encoding, bool BinPackInconclusiveFunctions)
Constructs a ContinuationIndenter to format Line starting in column FirstIndent.
llvm::Optional< FormatStyle > get(StringRef Delimiter) const
FormatToken * NextOperator
If this is an operator (or "."/"->") in a sequence of operators with the same precedence, points to the next operator.
Definition: FormatToken.h:264
BreakConstructorInitializersStyle BreakConstructorInitializers
The constructor initializers style to use.
Definition: Format.h:821
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
bool ClosesTemplateDeclaration
true if this is the ">" of "template<..>".
Definition: FormatToken.h:185
FormatToken * MatchingParen
If this is a bracket, this points to the matching one.
Definition: FormatToken.h:277
std::vector< RawStringFormat > RawStringFormats
Raw string delimiters denoting that the raw string contents are code in a particular language and can...
Definition: Format.h:1363
SmallVector< AnnotatedLine *, 1 > Children
If this token starts a block, this contains all the unwrapped lines in it.
Definition: FormatToken.h:287
unsigned ConstructorInitializerIndentWidth
The number of characters to use for indentation of constructor initializer lists. ...
Definition: Format.h:905
BinaryOperatorStyle BreakBeforeBinaryOperators
The way to wrap binary operators.
Definition: Format.h:434
bool opensBlockOrBlockTypeList(const FormatStyle &Style) const
Returns true if this tokens starts a block-type list, i.e.
Definition: FormatToken.h:465
Indents directives after the hash.
Definition: Format.h:1075
bool opensScope() const
Returns whether Tok is ([{ or a template opening <.
Definition: FormatToken.h:352
bool MustBreakBefore
Whether there must be a line break before this token.
Definition: FormatToken.h:162
unsigned StartOfLineLevel
The NestingLevel at the start of this line.
Should be used for Protocol Buffer messages in text format (https://developers.google.com/protocol-buffers/).
Definition: Format.h:1180
unsigned StartOfStringLiteral
The start column of the string literal, if we&#39;re in a string literal sequence, 0 otherwise.
StringRef Text
Definition: Format.cpp:1336
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:121
bool isStringLiteral() const
Definition: FormatToken.h:329
SourceLocation getBegin() const
unsigned MaxEmptyLinesToKeep
The maximum number of consecutive empty lines to keep.
Definition: Format.h:1229
BraceBlockKind BlockKind
Contains the kind of block if this token is a brace.
Definition: FormatToken.h:174
bool PartOfMultiVariableDeclStmt
Is this token part of a DeclStmt defining multiple variables?
Definition: FormatToken.h:269
This class handles loading and caching of source files into memory.
static llvm::Optional< StringRef > getRawStringDelimiter(StringRef TokenText)
unsigned LastLineColumnWidth
Contains the width in columns of the last line of a multi-line token.
Definition: FormatToken.h:150
const encoding::Encoding Encoding
const FormatStyle & Style
bool BinPackParameters
If false, a function declaration&#39;s or function definition&#39;s parameters will either all be on the same...
Definition: Format.h:391