clang  6.0.0svn
UnwrappedLineParser.cpp
Go to the documentation of this file.
1 //===--- UnwrappedLineParser.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 contains the implementation of the UnwrappedLineParser,
12 /// which turns a stream of tokens into UnwrappedLines.
13 ///
14 //===----------------------------------------------------------------------===//
15 
16 #include "UnwrappedLineParser.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/Support/Debug.h"
19 #include "llvm/Support/raw_ostream.h"
20 
21 #include <algorithm>
22 
23 #define DEBUG_TYPE "format-parser"
24 
25 namespace clang {
26 namespace format {
27 
29 public:
30  virtual ~FormatTokenSource() {}
31  virtual FormatToken *getNextToken() = 0;
32 
33  virtual unsigned getPosition() = 0;
34  virtual FormatToken *setPosition(unsigned Position) = 0;
35 };
36 
37 namespace {
38 
39 class ScopedDeclarationState {
40 public:
41  ScopedDeclarationState(UnwrappedLine &Line, std::vector<bool> &Stack,
42  bool MustBeDeclaration)
43  : Line(Line), Stack(Stack) {
44  Line.MustBeDeclaration = MustBeDeclaration;
45  Stack.push_back(MustBeDeclaration);
46  }
47  ~ScopedDeclarationState() {
48  Stack.pop_back();
49  if (!Stack.empty())
50  Line.MustBeDeclaration = Stack.back();
51  else
52  Line.MustBeDeclaration = true;
53  }
54 
55 private:
57  std::vector<bool> &Stack;
58 };
59 
60 static bool isLineComment(const FormatToken &FormatTok) {
61  return FormatTok.is(tok::comment) && !FormatTok.TokenText.startswith("/*");
62 }
63 
64 // Checks if \p FormatTok is a line comment that continues the line comment
65 // \p Previous. The original column of \p MinColumnToken is used to determine
66 // whether \p FormatTok is indented enough to the right to continue \p Previous.
67 static bool continuesLineComment(const FormatToken &FormatTok,
68  const FormatToken *Previous,
69  const FormatToken *MinColumnToken) {
70  if (!Previous || !MinColumnToken)
71  return false;
72  unsigned MinContinueColumn =
73  MinColumnToken->OriginalColumn + (isLineComment(*MinColumnToken) ? 0 : 1);
74  return isLineComment(FormatTok) && FormatTok.NewlinesBefore == 1 &&
75  isLineComment(*Previous) &&
76  FormatTok.OriginalColumn >= MinContinueColumn;
77 }
78 
79 class ScopedMacroState : public FormatTokenSource {
80 public:
81  ScopedMacroState(UnwrappedLine &Line, FormatTokenSource *&TokenSource,
82  FormatToken *&ResetToken)
83  : Line(Line), TokenSource(TokenSource), ResetToken(ResetToken),
84  PreviousLineLevel(Line.Level), PreviousTokenSource(TokenSource),
85  Token(nullptr), PreviousToken(nullptr) {
86  TokenSource = this;
87  Line.Level = 0;
88  Line.InPPDirective = true;
89  }
90 
91  ~ScopedMacroState() override {
92  TokenSource = PreviousTokenSource;
93  ResetToken = Token;
94  Line.InPPDirective = false;
95  Line.Level = PreviousLineLevel;
96  }
97 
98  FormatToken *getNextToken() override {
99  // The \c UnwrappedLineParser guards against this by never calling
100  // \c getNextToken() after it has encountered the first eof token.
101  assert(!eof());
102  PreviousToken = Token;
103  Token = PreviousTokenSource->getNextToken();
104  if (eof())
105  return getFakeEOF();
106  return Token;
107  }
108 
109  unsigned getPosition() override { return PreviousTokenSource->getPosition(); }
110 
111  FormatToken *setPosition(unsigned Position) override {
112  PreviousToken = nullptr;
113  Token = PreviousTokenSource->setPosition(Position);
114  return Token;
115  }
116 
117 private:
118  bool eof() {
119  return Token && Token->HasUnescapedNewline &&
120  !continuesLineComment(*Token, PreviousToken,
121  /*MinColumnToken=*/PreviousToken);
122  }
123 
124  FormatToken *getFakeEOF() {
125  static bool EOFInitialized = false;
126  static FormatToken FormatTok;
127  if (!EOFInitialized) {
128  FormatTok.Tok.startToken();
129  FormatTok.Tok.setKind(tok::eof);
130  EOFInitialized = true;
131  }
132  return &FormatTok;
133  }
134 
136  FormatTokenSource *&TokenSource;
137  FormatToken *&ResetToken;
138  unsigned PreviousLineLevel;
139  FormatTokenSource *PreviousTokenSource;
140 
142  FormatToken *PreviousToken;
143 };
144 
145 } // end anonymous namespace
146 
148 public:
150  bool SwitchToPreprocessorLines = false)
151  : Parser(Parser), OriginalLines(Parser.CurrentLines) {
152  if (SwitchToPreprocessorLines)
153  Parser.CurrentLines = &Parser.PreprocessorDirectives;
154  else if (!Parser.Line->Tokens.empty())
155  Parser.CurrentLines = &Parser.Line->Tokens.back().Children;
156  PreBlockLine = std::move(Parser.Line);
157  Parser.Line = llvm::make_unique<UnwrappedLine>();
158  Parser.Line->Level = PreBlockLine->Level;
159  Parser.Line->InPPDirective = PreBlockLine->InPPDirective;
160  }
161 
163  if (!Parser.Line->Tokens.empty()) {
164  Parser.addUnwrappedLine();
165  }
166  assert(Parser.Line->Tokens.empty());
167  Parser.Line = std::move(PreBlockLine);
168  if (Parser.CurrentLines == &Parser.PreprocessorDirectives)
169  Parser.MustBreakBeforeNextToken = true;
170  Parser.CurrentLines = OriginalLines;
171  }
172 
173 private:
175 
176  std::unique_ptr<UnwrappedLine> PreBlockLine;
177  SmallVectorImpl<UnwrappedLine> *OriginalLines;
178 };
179 
181 public:
183  const FormatStyle &Style, unsigned &LineLevel)
184  : LineLevel(LineLevel), OldLineLevel(LineLevel) {
186  Parser->addUnwrappedLine();
187  if (Style.BraceWrapping.IndentBraces)
188  ++LineLevel;
189  }
190  ~CompoundStatementIndenter() { LineLevel = OldLineLevel; }
191 
192 private:
193  unsigned &LineLevel;
194  unsigned OldLineLevel;
195 };
196 
197 namespace {
198 
199 class IndexedTokenSource : public FormatTokenSource {
200 public:
201  IndexedTokenSource(ArrayRef<FormatToken *> Tokens)
202  : Tokens(Tokens), Position(-1) {}
203 
204  FormatToken *getNextToken() override {
205  ++Position;
206  return Tokens[Position];
207  }
208 
209  unsigned getPosition() override {
210  assert(Position >= 0);
211  return Position;
212  }
213 
214  FormatToken *setPosition(unsigned P) override {
215  Position = P;
216  return Tokens[Position];
217  }
218 
219  void reset() { Position = -1; }
220 
221 private:
223  int Position;
224 };
225 
226 } // end anonymous namespace
227 
229  const AdditionalKeywords &Keywords,
230  unsigned FirstStartColumn,
232  UnwrappedLineConsumer &Callback)
233  : Line(new UnwrappedLine), MustBreakBeforeNextToken(false),
234  CurrentLines(&Lines), Style(Style), Keywords(Keywords),
235  CommentPragmasRegex(Style.CommentPragmas), Tokens(nullptr),
236  Callback(Callback), AllTokens(Tokens), PPBranchLevel(-1),
237  IfNdefCondition(nullptr), FoundIncludeGuardStart(false),
238  IncludeGuardRejected(false), FirstStartColumn(FirstStartColumn) {}
239 
240 void UnwrappedLineParser::reset() {
241  PPBranchLevel = -1;
242  IfNdefCondition = nullptr;
243  FoundIncludeGuardStart = false;
244  IncludeGuardRejected = false;
245  Line.reset(new UnwrappedLine);
246  CommentsBeforeNextToken.clear();
247  FormatTok = nullptr;
248  MustBreakBeforeNextToken = false;
249  PreprocessorDirectives.clear();
250  CurrentLines = &Lines;
251  DeclarationScopeStack.clear();
252  PPStack.clear();
253  Line->FirstStartColumn = FirstStartColumn;
254 }
255 
257  IndexedTokenSource TokenSource(AllTokens);
258  Line->FirstStartColumn = FirstStartColumn;
259  do {
260  DEBUG(llvm::dbgs() << "----\n");
261  reset();
262  Tokens = &TokenSource;
263  TokenSource.reset();
264 
265  readToken();
266  parseFile();
267  // Create line with eof token.
268  pushToken(FormatTok);
269  addUnwrappedLine();
270 
271  for (SmallVectorImpl<UnwrappedLine>::iterator I = Lines.begin(),
272  E = Lines.end();
273  I != E; ++I) {
274  Callback.consumeUnwrappedLine(*I);
275  }
276  Callback.finishRun();
277  Lines.clear();
278  while (!PPLevelBranchIndex.empty() &&
279  PPLevelBranchIndex.back() + 1 >= PPLevelBranchCount.back()) {
280  PPLevelBranchIndex.resize(PPLevelBranchIndex.size() - 1);
281  PPLevelBranchCount.resize(PPLevelBranchCount.size() - 1);
282  }
283  if (!PPLevelBranchIndex.empty()) {
284  ++PPLevelBranchIndex.back();
285  assert(PPLevelBranchIndex.size() == PPLevelBranchCount.size());
286  assert(PPLevelBranchIndex.back() <= PPLevelBranchCount.back());
287  }
288  } while (!PPLevelBranchIndex.empty());
289 }
290 
291 void UnwrappedLineParser::parseFile() {
292  // The top-level context in a file always has declarations, except for pre-
293  // processor directives and JavaScript files.
294  bool MustBeDeclaration =
295  !Line->InPPDirective && Style.Language != FormatStyle::LK_JavaScript;
296  ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
297  MustBeDeclaration);
298  if (Style.Language == FormatStyle::LK_TextProto)
299  parseBracedList();
300  else
301  parseLevel(/*HasOpeningBrace=*/false);
302  // Make sure to format the remaining tokens.
303  flushComments(true);
304  addUnwrappedLine();
305 }
306 
307 void UnwrappedLineParser::parseLevel(bool HasOpeningBrace) {
308  bool SwitchLabelEncountered = false;
309  do {
310  tok::TokenKind kind = FormatTok->Tok.getKind();
311  if (FormatTok->Type == TT_MacroBlockBegin) {
312  kind = tok::l_brace;
313  } else if (FormatTok->Type == TT_MacroBlockEnd) {
314  kind = tok::r_brace;
315  }
316 
317  switch (kind) {
318  case tok::comment:
319  nextToken();
320  addUnwrappedLine();
321  break;
322  case tok::l_brace:
323  // FIXME: Add parameter whether this can happen - if this happens, we must
324  // be in a non-declaration context.
325  if (!FormatTok->is(TT_MacroBlockBegin) && tryToParseBracedList())
326  continue;
327  parseBlock(/*MustBeDeclaration=*/false);
328  addUnwrappedLine();
329  break;
330  case tok::r_brace:
331  if (HasOpeningBrace)
332  return;
333  nextToken();
334  addUnwrappedLine();
335  break;
336  case tok::kw_default:
337  case tok::kw_case:
338  if (Style.Language == FormatStyle::LK_JavaScript &&
339  Line->MustBeDeclaration) {
340  // A 'case: string' style field declaration.
341  parseStructuralElement();
342  break;
343  }
344  if (!SwitchLabelEncountered &&
345  (Style.IndentCaseLabels || (Line->InPPDirective && Line->Level == 1)))
346  ++Line->Level;
347  SwitchLabelEncountered = true;
348  parseStructuralElement();
349  break;
350  default:
351  parseStructuralElement();
352  break;
353  }
354  } while (!eof());
355 }
356 
357 void UnwrappedLineParser::calculateBraceTypes(bool ExpectClassBody) {
358  // We'll parse forward through the tokens until we hit
359  // a closing brace or eof - note that getNextToken() will
360  // parse macros, so this will magically work inside macro
361  // definitions, too.
362  unsigned StoredPosition = Tokens->getPosition();
363  FormatToken *Tok = FormatTok;
364  const FormatToken *PrevTok = Tok->Previous;
365  // Keep a stack of positions of lbrace tokens. We will
366  // update information about whether an lbrace starts a
367  // braced init list or a different block during the loop.
368  SmallVector<FormatToken *, 8> LBraceStack;
369  assert(Tok->Tok.is(tok::l_brace));
370  do {
371  // Get next non-comment token.
372  FormatToken *NextTok;
373  unsigned ReadTokens = 0;
374  do {
375  NextTok = Tokens->getNextToken();
376  ++ReadTokens;
377  } while (NextTok->is(tok::comment));
378 
379  switch (Tok->Tok.getKind()) {
380  case tok::l_brace:
381  if (Style.Language == FormatStyle::LK_JavaScript && PrevTok) {
382  if (PrevTok->isOneOf(tok::colon, tok::less))
383  // A ':' indicates this code is in a type, or a braced list
384  // following a label in an object literal ({a: {b: 1}}).
385  // A '<' could be an object used in a comparison, but that is nonsense
386  // code (can never return true), so more likely it is a generic type
387  // argument (`X<{a: string; b: number}>`).
388  // The code below could be confused by semicolons between the
389  // individual members in a type member list, which would normally
390  // trigger BK_Block. In both cases, this must be parsed as an inline
391  // braced init.
392  Tok->BlockKind = BK_BracedInit;
393  else if (PrevTok->is(tok::r_paren))
394  // `) { }` can only occur in function or method declarations in JS.
395  Tok->BlockKind = BK_Block;
396  } else {
397  Tok->BlockKind = BK_Unknown;
398  }
399  LBraceStack.push_back(Tok);
400  break;
401  case tok::r_brace:
402  if (LBraceStack.empty())
403  break;
404  if (LBraceStack.back()->BlockKind == BK_Unknown) {
405  bool ProbablyBracedList = false;
406  if (Style.Language == FormatStyle::LK_Proto) {
407  ProbablyBracedList = NextTok->isOneOf(tok::comma, tok::r_square);
408  } else {
409  // Using OriginalColumn to distinguish between ObjC methods and
410  // binary operators is a bit hacky.
411  bool NextIsObjCMethod = NextTok->isOneOf(tok::plus, tok::minus) &&
412  NextTok->OriginalColumn == 0;
413 
414  // If there is a comma, semicolon or right paren after the closing
415  // brace, we assume this is a braced initializer list. Note that
416  // regardless how we mark inner braces here, we will overwrite the
417  // BlockKind later if we parse a braced list (where all blocks
418  // inside are by default braced lists), or when we explicitly detect
419  // blocks (for example while parsing lambdas).
420  // FIXME: Some of these do not apply to JS, e.g. "} {" can never be a
421  // braced list in JS.
422  ProbablyBracedList =
424  NextTok->isOneOf(Keywords.kw_of, Keywords.kw_in,
425  Keywords.kw_as)) ||
426  (Style.isCpp() && NextTok->is(tok::l_paren)) ||
427  NextTok->isOneOf(tok::comma, tok::period, tok::colon,
428  tok::r_paren, tok::r_square, tok::l_brace,
429  tok::l_square, tok::ellipsis) ||
430  (NextTok->is(tok::identifier) &&
431  !PrevTok->isOneOf(tok::semi, tok::r_brace, tok::l_brace)) ||
432  (NextTok->is(tok::semi) &&
433  (!ExpectClassBody || LBraceStack.size() != 1)) ||
434  (NextTok->isBinaryOperator() && !NextIsObjCMethod);
435  }
436  if (ProbablyBracedList) {
437  Tok->BlockKind = BK_BracedInit;
438  LBraceStack.back()->BlockKind = BK_BracedInit;
439  } else {
440  Tok->BlockKind = BK_Block;
441  LBraceStack.back()->BlockKind = BK_Block;
442  }
443  }
444  LBraceStack.pop_back();
445  break;
446  case tok::at:
447  case tok::semi:
448  case tok::kw_if:
449  case tok::kw_while:
450  case tok::kw_for:
451  case tok::kw_switch:
452  case tok::kw_try:
453  case tok::kw___try:
454  if (!LBraceStack.empty() && LBraceStack.back()->BlockKind == BK_Unknown)
455  LBraceStack.back()->BlockKind = BK_Block;
456  break;
457  default:
458  break;
459  }
460  PrevTok = Tok;
461  Tok = NextTok;
462  } while (Tok->Tok.isNot(tok::eof) && !LBraceStack.empty());
463 
464  // Assume other blocks for all unclosed opening braces.
465  for (unsigned i = 0, e = LBraceStack.size(); i != e; ++i) {
466  if (LBraceStack[i]->BlockKind == BK_Unknown)
467  LBraceStack[i]->BlockKind = BK_Block;
468  }
469 
470  FormatTok = Tokens->setPosition(StoredPosition);
471 }
472 
473 template <class T>
474 static inline void hash_combine(std::size_t &seed, const T &v) {
475  std::hash<T> hasher;
476  seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
477 }
478 
479 size_t UnwrappedLineParser::computePPHash() const {
480  size_t h = 0;
481  for (const auto &i : PPStack) {
482  hash_combine(h, size_t(i.Kind));
483  hash_combine(h, i.Line);
484  }
485  return h;
486 }
487 
488 void UnwrappedLineParser::parseBlock(bool MustBeDeclaration, bool AddLevel,
489  bool MunchSemi) {
490  assert(FormatTok->isOneOf(tok::l_brace, TT_MacroBlockBegin) &&
491  "'{' or macro block token expected");
492  const bool MacroBlock = FormatTok->is(TT_MacroBlockBegin);
493  FormatTok->BlockKind = BK_Block;
494 
495  size_t PPStartHash = computePPHash();
496 
497  unsigned InitialLevel = Line->Level;
498  nextToken(/*LevelDifference=*/AddLevel ? 1 : 0);
499 
500  if (MacroBlock && FormatTok->is(tok::l_paren))
501  parseParens();
502 
503  size_t NbPreprocessorDirectives =
504  CurrentLines == &Lines ? PreprocessorDirectives.size() : 0;
505  addUnwrappedLine();
506  size_t OpeningLineIndex =
507  CurrentLines->empty()
509  : (CurrentLines->size() - 1 - NbPreprocessorDirectives);
510 
511  ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
512  MustBeDeclaration);
513  if (AddLevel)
514  ++Line->Level;
515  parseLevel(/*HasOpeningBrace=*/true);
516 
517  if (eof())
518  return;
519 
520  if (MacroBlock ? !FormatTok->is(TT_MacroBlockEnd)
521  : !FormatTok->is(tok::r_brace)) {
522  Line->Level = InitialLevel;
523  FormatTok->BlockKind = BK_Block;
524  return;
525  }
526 
527  size_t PPEndHash = computePPHash();
528 
529  // Munch the closing brace.
530  nextToken(/*LevelDifference=*/AddLevel ? -1 : 0);
531 
532  if (MacroBlock && FormatTok->is(tok::l_paren))
533  parseParens();
534 
535  if (MunchSemi && FormatTok->Tok.is(tok::semi))
536  nextToken();
537  Line->Level = InitialLevel;
538 
539  if (PPStartHash == PPEndHash) {
540  Line->MatchingOpeningBlockLineIndex = OpeningLineIndex;
541  if (OpeningLineIndex != UnwrappedLine::kInvalidIndex) {
542  // Update the opening line to add the forward reference as well
543  (*CurrentLines)[OpeningLineIndex].MatchingOpeningBlockLineIndex =
544  CurrentLines->size() - 1;
545  }
546  }
547 }
548 
549 static bool isGoogScope(const UnwrappedLine &Line) {
550  // FIXME: Closure-library specific stuff should not be hard-coded but be
551  // configurable.
552  if (Line.Tokens.size() < 4)
553  return false;
554  auto I = Line.Tokens.begin();
555  if (I->Tok->TokenText != "goog")
556  return false;
557  ++I;
558  if (I->Tok->isNot(tok::period))
559  return false;
560  ++I;
561  if (I->Tok->TokenText != "scope")
562  return false;
563  ++I;
564  return I->Tok->is(tok::l_paren);
565 }
566 
567 static bool isIIFE(const UnwrappedLine &Line,
568  const AdditionalKeywords &Keywords) {
569  // Look for the start of an immediately invoked anonymous function.
570  // https://en.wikipedia.org/wiki/Immediately-invoked_function_expression
571  // This is commonly done in JavaScript to create a new, anonymous scope.
572  // Example: (function() { ... })()
573  if (Line.Tokens.size() < 3)
574  return false;
575  auto I = Line.Tokens.begin();
576  if (I->Tok->isNot(tok::l_paren))
577  return false;
578  ++I;
579  if (I->Tok->isNot(Keywords.kw_function))
580  return false;
581  ++I;
582  return I->Tok->is(tok::l_paren);
583 }
584 
585 static bool ShouldBreakBeforeBrace(const FormatStyle &Style,
586  const FormatToken &InitialToken) {
587  if (InitialToken.is(tok::kw_namespace))
588  return Style.BraceWrapping.AfterNamespace;
589  if (InitialToken.is(tok::kw_class))
590  return Style.BraceWrapping.AfterClass;
591  if (InitialToken.is(tok::kw_union))
592  return Style.BraceWrapping.AfterUnion;
593  if (InitialToken.is(tok::kw_struct))
594  return Style.BraceWrapping.AfterStruct;
595  return false;
596 }
597 
598 void UnwrappedLineParser::parseChildBlock() {
599  FormatTok->BlockKind = BK_Block;
600  nextToken();
601  {
602  bool SkipIndent = (Style.Language == FormatStyle::LK_JavaScript &&
603  (isGoogScope(*Line) || isIIFE(*Line, Keywords)));
604  ScopedLineState LineState(*this);
605  ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
606  /*MustBeDeclaration=*/false);
607  Line->Level += SkipIndent ? 0 : 1;
608  parseLevel(/*HasOpeningBrace=*/true);
609  flushComments(isOnNewLine(*FormatTok));
610  Line->Level -= SkipIndent ? 0 : 1;
611  }
612  nextToken();
613 }
614 
615 void UnwrappedLineParser::parsePPDirective() {
616  assert(FormatTok->Tok.is(tok::hash) && "'#' expected");
617  ScopedMacroState MacroState(*Line, Tokens, FormatTok);
618  nextToken();
619 
620  if (!FormatTok->Tok.getIdentifierInfo()) {
621  parsePPUnknown();
622  return;
623  }
624 
625  switch (FormatTok->Tok.getIdentifierInfo()->getPPKeywordID()) {
626  case tok::pp_define:
627  parsePPDefine();
628  return;
629  case tok::pp_if:
630  parsePPIf(/*IfDef=*/false);
631  break;
632  case tok::pp_ifdef:
633  case tok::pp_ifndef:
634  parsePPIf(/*IfDef=*/true);
635  break;
636  case tok::pp_else:
637  parsePPElse();
638  break;
639  case tok::pp_elif:
640  parsePPElIf();
641  break;
642  case tok::pp_endif:
643  parsePPEndIf();
644  break;
645  default:
646  parsePPUnknown();
647  break;
648  }
649 }
650 
651 void UnwrappedLineParser::conditionalCompilationCondition(bool Unreachable) {
652  size_t Line = CurrentLines->size();
653  if (CurrentLines == &PreprocessorDirectives)
654  Line += Lines.size();
655 
656  if (Unreachable ||
657  (!PPStack.empty() && PPStack.back().Kind == PP_Unreachable))
658  PPStack.push_back({PP_Unreachable, Line});
659  else
660  PPStack.push_back({PP_Conditional, Line});
661 }
662 
663 void UnwrappedLineParser::conditionalCompilationStart(bool Unreachable) {
664  ++PPBranchLevel;
665  assert(PPBranchLevel >= 0 && PPBranchLevel <= (int)PPLevelBranchIndex.size());
666  if (PPBranchLevel == (int)PPLevelBranchIndex.size()) {
667  PPLevelBranchIndex.push_back(0);
668  PPLevelBranchCount.push_back(0);
669  }
670  PPChainBranchIndex.push(0);
671  bool Skip = PPLevelBranchIndex[PPBranchLevel] > 0;
672  conditionalCompilationCondition(Unreachable || Skip);
673 }
674 
675 void UnwrappedLineParser::conditionalCompilationAlternative() {
676  if (!PPStack.empty())
677  PPStack.pop_back();
678  assert(PPBranchLevel < (int)PPLevelBranchIndex.size());
679  if (!PPChainBranchIndex.empty())
680  ++PPChainBranchIndex.top();
681  conditionalCompilationCondition(
682  PPBranchLevel >= 0 && !PPChainBranchIndex.empty() &&
683  PPLevelBranchIndex[PPBranchLevel] != PPChainBranchIndex.top());
684 }
685 
686 void UnwrappedLineParser::conditionalCompilationEnd() {
687  assert(PPBranchLevel < (int)PPLevelBranchIndex.size());
688  if (PPBranchLevel >= 0 && !PPChainBranchIndex.empty()) {
689  if (PPChainBranchIndex.top() + 1 > PPLevelBranchCount[PPBranchLevel]) {
690  PPLevelBranchCount[PPBranchLevel] = PPChainBranchIndex.top() + 1;
691  }
692  }
693  // Guard against #endif's without #if.
694  if (PPBranchLevel > -1)
695  --PPBranchLevel;
696  if (!PPChainBranchIndex.empty())
697  PPChainBranchIndex.pop();
698  if (!PPStack.empty())
699  PPStack.pop_back();
700 }
701 
702 void UnwrappedLineParser::parsePPIf(bool IfDef) {
703  bool IfNDef = FormatTok->is(tok::pp_ifndef);
704  nextToken();
705  bool Unreachable = false;
706  if (!IfDef && (FormatTok->is(tok::kw_false) || FormatTok->TokenText == "0"))
707  Unreachable = true;
708  if (IfDef && !IfNDef && FormatTok->TokenText == "SWIG")
709  Unreachable = true;
710  conditionalCompilationStart(Unreachable);
711  FormatToken *IfCondition = FormatTok;
712  // If there's a #ifndef on the first line, and the only lines before it are
713  // comments, it could be an include guard.
714  bool MaybeIncludeGuard = IfNDef;
715  if (!IncludeGuardRejected && !FoundIncludeGuardStart && MaybeIncludeGuard) {
716  for (auto &Line : Lines) {
717  if (!Line.Tokens.front().Tok->is(tok::comment)) {
718  MaybeIncludeGuard = false;
719  IncludeGuardRejected = true;
720  break;
721  }
722  }
723  }
724  --PPBranchLevel;
725  parsePPUnknown();
726  ++PPBranchLevel;
727  if (!IncludeGuardRejected && !FoundIncludeGuardStart && MaybeIncludeGuard)
728  IfNdefCondition = IfCondition;
729 }
730 
731 void UnwrappedLineParser::parsePPElse() {
732  // If a potential include guard has an #else, it's not an include guard.
733  if (FoundIncludeGuardStart && PPBranchLevel == 0)
734  FoundIncludeGuardStart = false;
735  conditionalCompilationAlternative();
736  if (PPBranchLevel > -1)
737  --PPBranchLevel;
738  parsePPUnknown();
739  ++PPBranchLevel;
740 }
741 
742 void UnwrappedLineParser::parsePPElIf() { parsePPElse(); }
743 
744 void UnwrappedLineParser::parsePPEndIf() {
745  conditionalCompilationEnd();
746  parsePPUnknown();
747  // If the #endif of a potential include guard is the last thing in the file,
748  // then we count it as a real include guard and subtract one from every
749  // preprocessor indent.
750  unsigned TokenPosition = Tokens->getPosition();
751  FormatToken *PeekNext = AllTokens[TokenPosition];
752  if (FoundIncludeGuardStart && PPBranchLevel == -1 && PeekNext->is(tok::eof) &&
754  for (auto &Line : Lines)
755  if (Line.InPPDirective && Line.Level > 0)
756  --Line.Level;
757 }
758 
759 void UnwrappedLineParser::parsePPDefine() {
760  nextToken();
761 
762  if (FormatTok->Tok.getKind() != tok::identifier) {
763  parsePPUnknown();
764  return;
765  }
766  if (IfNdefCondition && IfNdefCondition->TokenText == FormatTok->TokenText) {
767  FoundIncludeGuardStart = true;
768  for (auto &Line : Lines) {
769  if (!Line.Tokens.front().Tok->isOneOf(tok::comment, tok::hash)) {
770  FoundIncludeGuardStart = false;
771  break;
772  }
773  }
774  }
775  IfNdefCondition = nullptr;
776  nextToken();
777  if (FormatTok->Tok.getKind() == tok::l_paren &&
778  FormatTok->WhitespaceRange.getBegin() ==
779  FormatTok->WhitespaceRange.getEnd()) {
780  parseParens();
781  }
783  Line->Level += PPBranchLevel + 1;
784  addUnwrappedLine();
785  ++Line->Level;
786 
787  // Errors during a preprocessor directive can only affect the layout of the
788  // preprocessor directive, and thus we ignore them. An alternative approach
789  // would be to use the same approach we use on the file level (no
790  // re-indentation if there was a structural error) within the macro
791  // definition.
792  parseFile();
793 }
794 
795 void UnwrappedLineParser::parsePPUnknown() {
796  do {
797  nextToken();
798  } while (!eof());
800  Line->Level += PPBranchLevel + 1;
801  addUnwrappedLine();
802  IfNdefCondition = nullptr;
803 }
804 
805 // Here we blacklist certain tokens that are not usually the first token in an
806 // unwrapped line. This is used in attempt to distinguish macro calls without
807 // trailing semicolons from other constructs split to several lines.
808 static bool tokenCanStartNewLine(const clang::Token &Tok) {
809  // Semicolon can be a null-statement, l_square can be a start of a macro or
810  // a C++11 attribute, but this doesn't seem to be common.
811  return Tok.isNot(tok::semi) && Tok.isNot(tok::l_brace) &&
812  Tok.isNot(tok::l_square) &&
813  // Tokens that can only be used as binary operators and a part of
814  // overloaded operator names.
815  Tok.isNot(tok::period) && Tok.isNot(tok::periodstar) &&
816  Tok.isNot(tok::arrow) && Tok.isNot(tok::arrowstar) &&
817  Tok.isNot(tok::less) && Tok.isNot(tok::greater) &&
818  Tok.isNot(tok::slash) && Tok.isNot(tok::percent) &&
819  Tok.isNot(tok::lessless) && Tok.isNot(tok::greatergreater) &&
820  Tok.isNot(tok::equal) && Tok.isNot(tok::plusequal) &&
821  Tok.isNot(tok::minusequal) && Tok.isNot(tok::starequal) &&
822  Tok.isNot(tok::slashequal) && Tok.isNot(tok::percentequal) &&
823  Tok.isNot(tok::ampequal) && Tok.isNot(tok::pipeequal) &&
824  Tok.isNot(tok::caretequal) && Tok.isNot(tok::greatergreaterequal) &&
825  Tok.isNot(tok::lesslessequal) &&
826  // Colon is used in labels, base class lists, initializer lists,
827  // range-based for loops, ternary operator, but should never be the
828  // first token in an unwrapped line.
829  Tok.isNot(tok::colon) &&
830  // 'noexcept' is a trailing annotation.
831  Tok.isNot(tok::kw_noexcept);
832 }
833 
834 static bool mustBeJSIdent(const AdditionalKeywords &Keywords,
835  const FormatToken *FormatTok) {
836  // FIXME: This returns true for C/C++ keywords like 'struct'.
837  return FormatTok->is(tok::identifier) &&
838  (FormatTok->Tok.getIdentifierInfo() == nullptr ||
839  !FormatTok->isOneOf(
840  Keywords.kw_in, Keywords.kw_of, Keywords.kw_as, Keywords.kw_async,
841  Keywords.kw_await, Keywords.kw_yield, Keywords.kw_finally,
842  Keywords.kw_function, Keywords.kw_import, Keywords.kw_is,
843  Keywords.kw_let, Keywords.kw_var, tok::kw_const,
844  Keywords.kw_abstract, Keywords.kw_extends, Keywords.kw_implements,
845  Keywords.kw_instanceof, Keywords.kw_interface, Keywords.kw_throws,
846  Keywords.kw_from));
847 }
848 
849 static bool mustBeJSIdentOrValue(const AdditionalKeywords &Keywords,
850  const FormatToken *FormatTok) {
851  return FormatTok->Tok.isLiteral() ||
852  FormatTok->isOneOf(tok::kw_true, tok::kw_false) ||
853  mustBeJSIdent(Keywords, FormatTok);
854 }
855 
856 // isJSDeclOrStmt returns true if |FormatTok| starts a declaration or statement
857 // when encountered after a value (see mustBeJSIdentOrValue).
858 static bool isJSDeclOrStmt(const AdditionalKeywords &Keywords,
859  const FormatToken *FormatTok) {
860  return FormatTok->isOneOf(
861  tok::kw_return, Keywords.kw_yield,
862  // conditionals
863  tok::kw_if, tok::kw_else,
864  // loops
865  tok::kw_for, tok::kw_while, tok::kw_do, tok::kw_continue, tok::kw_break,
866  // switch/case
867  tok::kw_switch, tok::kw_case,
868  // exceptions
869  tok::kw_throw, tok::kw_try, tok::kw_catch, Keywords.kw_finally,
870  // declaration
871  tok::kw_const, tok::kw_class, Keywords.kw_var, Keywords.kw_let,
872  Keywords.kw_async, Keywords.kw_function,
873  // import/export
874  Keywords.kw_import, tok::kw_export);
875 }
876 
877 // readTokenWithJavaScriptASI reads the next token and terminates the current
878 // line if JavaScript Automatic Semicolon Insertion must
879 // happen between the current token and the next token.
880 //
881 // This method is conservative - it cannot cover all edge cases of JavaScript,
882 // but only aims to correctly handle certain well known cases. It *must not*
883 // return true in speculative cases.
884 void UnwrappedLineParser::readTokenWithJavaScriptASI() {
885  FormatToken *Previous = FormatTok;
886  readToken();
887  FormatToken *Next = FormatTok;
888 
889  bool IsOnSameLine =
890  CommentsBeforeNextToken.empty()
891  ? Next->NewlinesBefore == 0
892  : CommentsBeforeNextToken.front()->NewlinesBefore == 0;
893  if (IsOnSameLine)
894  return;
895 
896  bool PreviousMustBeValue = mustBeJSIdentOrValue(Keywords, Previous);
897  bool PreviousStartsTemplateExpr =
898  Previous->is(TT_TemplateString) && Previous->TokenText.endswith("${");
899  if (PreviousMustBeValue || Previous->is(tok::r_paren)) {
900  // If the line contains an '@' sign, the previous token might be an
901  // annotation, which can precede another identifier/value.
902  bool HasAt = std::find_if(Line->Tokens.begin(), Line->Tokens.end(),
903  [](UnwrappedLineNode &LineNode) {
904  return LineNode.Tok->is(tok::at);
905  }) != Line->Tokens.end();
906  if (HasAt)
907  return;
908  }
909  if (Next->is(tok::exclaim) && PreviousMustBeValue)
910  return addUnwrappedLine();
911  bool NextMustBeValue = mustBeJSIdentOrValue(Keywords, Next);
912  bool NextEndsTemplateExpr =
913  Next->is(TT_TemplateString) && Next->TokenText.startswith("}");
914  if (NextMustBeValue && !NextEndsTemplateExpr && !PreviousStartsTemplateExpr &&
915  (PreviousMustBeValue ||
916  Previous->isOneOf(tok::r_square, tok::r_paren, tok::plusplus,
917  tok::minusminus)))
918  return addUnwrappedLine();
919  if ((PreviousMustBeValue || Previous->is(tok::r_paren)) &&
920  isJSDeclOrStmt(Keywords, Next))
921  return addUnwrappedLine();
922 }
923 
924 void UnwrappedLineParser::parseStructuralElement() {
925  assert(!FormatTok->is(tok::l_brace));
926  if (Style.Language == FormatStyle::LK_TableGen &&
927  FormatTok->is(tok::pp_include)) {
928  nextToken();
929  if (FormatTok->is(tok::string_literal))
930  nextToken();
931  addUnwrappedLine();
932  return;
933  }
934  switch (FormatTok->Tok.getKind()) {
935  case tok::at:
936  nextToken();
937  if (FormatTok->Tok.is(tok::l_brace)) {
938  nextToken();
939  parseBracedList();
940  break;
941  }
942  switch (FormatTok->Tok.getObjCKeywordID()) {
943  case tok::objc_public:
944  case tok::objc_protected:
945  case tok::objc_package:
946  case tok::objc_private:
947  return parseAccessSpecifier();
948  case tok::objc_interface:
949  case tok::objc_implementation:
950  return parseObjCInterfaceOrImplementation();
951  case tok::objc_protocol:
952  return parseObjCProtocol();
953  case tok::objc_end:
954  return; // Handled by the caller.
955  case tok::objc_optional:
956  case tok::objc_required:
957  nextToken();
958  addUnwrappedLine();
959  return;
960  case tok::objc_autoreleasepool:
961  nextToken();
962  if (FormatTok->Tok.is(tok::l_brace)) {
964  addUnwrappedLine();
965  parseBlock(/*MustBeDeclaration=*/false);
966  }
967  addUnwrappedLine();
968  return;
969  case tok::objc_try:
970  // This branch isn't strictly necessary (the kw_try case below would
971  // do this too after the tok::at is parsed above). But be explicit.
972  parseTryCatch();
973  return;
974  default:
975  break;
976  }
977  break;
978  case tok::kw_asm:
979  nextToken();
980  if (FormatTok->is(tok::l_brace)) {
981  FormatTok->Type = TT_InlineASMBrace;
982  nextToken();
983  while (FormatTok && FormatTok->isNot(tok::eof)) {
984  if (FormatTok->is(tok::r_brace)) {
985  FormatTok->Type = TT_InlineASMBrace;
986  nextToken();
987  addUnwrappedLine();
988  break;
989  }
990  FormatTok->Finalized = true;
991  nextToken();
992  }
993  }
994  break;
995  case tok::kw_namespace:
996  parseNamespace();
997  return;
998  case tok::kw_inline:
999  nextToken();
1000  if (FormatTok->Tok.is(tok::kw_namespace)) {
1001  parseNamespace();
1002  return;
1003  }
1004  break;
1005  case tok::kw_public:
1006  case tok::kw_protected:
1007  case tok::kw_private:
1008  if (Style.Language == FormatStyle::LK_Java ||
1010  nextToken();
1011  else
1012  parseAccessSpecifier();
1013  return;
1014  case tok::kw_if:
1015  parseIfThenElse();
1016  return;
1017  case tok::kw_for:
1018  case tok::kw_while:
1019  parseForOrWhileLoop();
1020  return;
1021  case tok::kw_do:
1022  parseDoWhile();
1023  return;
1024  case tok::kw_switch:
1025  if (Style.Language == FormatStyle::LK_JavaScript && Line->MustBeDeclaration)
1026  // 'switch: string' field declaration.
1027  break;
1028  parseSwitch();
1029  return;
1030  case tok::kw_default:
1031  if (Style.Language == FormatStyle::LK_JavaScript && Line->MustBeDeclaration)
1032  // 'default: string' field declaration.
1033  break;
1034  nextToken();
1035  parseLabel();
1036  return;
1037  case tok::kw_case:
1038  if (Style.Language == FormatStyle::LK_JavaScript && Line->MustBeDeclaration)
1039  // 'case: string' field declaration.
1040  break;
1041  parseCaseLabel();
1042  return;
1043  case tok::kw_try:
1044  case tok::kw___try:
1045  parseTryCatch();
1046  return;
1047  case tok::kw_extern:
1048  nextToken();
1049  if (FormatTok->Tok.is(tok::string_literal)) {
1050  nextToken();
1051  if (FormatTok->Tok.is(tok::l_brace)) {
1052  if (Style.BraceWrapping.AfterExternBlock) {
1053  addUnwrappedLine();
1054  parseBlock(/*MustBeDeclaration=*/true);
1055  } else {
1056  parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/false);
1057  }
1058  addUnwrappedLine();
1059  return;
1060  }
1061  }
1062  break;
1063  case tok::kw_export:
1064  if (Style.Language == FormatStyle::LK_JavaScript) {
1065  parseJavaScriptEs6ImportExport();
1066  return;
1067  }
1068  break;
1069  case tok::identifier:
1070  if (FormatTok->is(TT_ForEachMacro)) {
1071  parseForOrWhileLoop();
1072  return;
1073  }
1074  if (FormatTok->is(TT_MacroBlockBegin)) {
1075  parseBlock(/*MustBeDeclaration=*/false, /*AddLevel=*/true,
1076  /*MunchSemi=*/false);
1077  return;
1078  }
1079  if (FormatTok->is(Keywords.kw_import)) {
1080  if (Style.Language == FormatStyle::LK_JavaScript) {
1081  parseJavaScriptEs6ImportExport();
1082  return;
1083  }
1084  if (Style.Language == FormatStyle::LK_Proto) {
1085  nextToken();
1086  if (FormatTok->is(tok::kw_public))
1087  nextToken();
1088  if (!FormatTok->is(tok::string_literal))
1089  return;
1090  nextToken();
1091  if (FormatTok->is(tok::semi))
1092  nextToken();
1093  addUnwrappedLine();
1094  return;
1095  }
1096  }
1097  if (Style.isCpp() &&
1098  FormatTok->isOneOf(Keywords.kw_signals, Keywords.kw_qsignals,
1099  Keywords.kw_slots, Keywords.kw_qslots)) {
1100  nextToken();
1101  if (FormatTok->is(tok::colon)) {
1102  nextToken();
1103  addUnwrappedLine();
1104  return;
1105  }
1106  }
1107  // In all other cases, parse the declaration.
1108  break;
1109  default:
1110  break;
1111  }
1112  do {
1113  const FormatToken *Previous = FormatTok->Previous;
1114  switch (FormatTok->Tok.getKind()) {
1115  case tok::at:
1116  nextToken();
1117  if (FormatTok->Tok.is(tok::l_brace)) {
1118  nextToken();
1119  parseBracedList();
1120  }
1121  break;
1122  case tok::kw_enum:
1123  // Ignore if this is part of "template <enum ...".
1124  if (Previous && Previous->is(tok::less)) {
1125  nextToken();
1126  break;
1127  }
1128 
1129  // parseEnum falls through and does not yet add an unwrapped line as an
1130  // enum definition can start a structural element.
1131  if (!parseEnum())
1132  break;
1133  // This only applies for C++.
1134  if (!Style.isCpp()) {
1135  addUnwrappedLine();
1136  return;
1137  }
1138  break;
1139  case tok::kw_typedef:
1140  nextToken();
1141  if (FormatTok->isOneOf(Keywords.kw_NS_ENUM, Keywords.kw_NS_OPTIONS,
1142  Keywords.kw_CF_ENUM, Keywords.kw_CF_OPTIONS))
1143  parseEnum();
1144  break;
1145  case tok::kw_struct:
1146  case tok::kw_union:
1147  case tok::kw_class:
1148  // parseRecord falls through and does not yet add an unwrapped line as a
1149  // record declaration or definition can start a structural element.
1150  parseRecord();
1151  // This does not apply for Java and JavaScript.
1152  if (Style.Language == FormatStyle::LK_Java ||
1154  if (FormatTok->is(tok::semi))
1155  nextToken();
1156  addUnwrappedLine();
1157  return;
1158  }
1159  break;
1160  case tok::period:
1161  nextToken();
1162  // In Java, classes have an implicit static member "class".
1163  if (Style.Language == FormatStyle::LK_Java && FormatTok &&
1164  FormatTok->is(tok::kw_class))
1165  nextToken();
1166  if (Style.Language == FormatStyle::LK_JavaScript && FormatTok &&
1167  FormatTok->Tok.getIdentifierInfo())
1168  // JavaScript only has pseudo keywords, all keywords are allowed to
1169  // appear in "IdentifierName" positions. See http://es5.github.io/#x7.6
1170  nextToken();
1171  break;
1172  case tok::semi:
1173  nextToken();
1174  addUnwrappedLine();
1175  return;
1176  case tok::r_brace:
1177  addUnwrappedLine();
1178  return;
1179  case tok::l_paren:
1180  parseParens();
1181  break;
1182  case tok::kw_operator:
1183  nextToken();
1184  if (FormatTok->isBinaryOperator())
1185  nextToken();
1186  break;
1187  case tok::caret:
1188  nextToken();
1189  if (FormatTok->Tok.isAnyIdentifier() ||
1190  FormatTok->isSimpleTypeSpecifier())
1191  nextToken();
1192  if (FormatTok->is(tok::l_paren))
1193  parseParens();
1194  if (FormatTok->is(tok::l_brace))
1195  parseChildBlock();
1196  break;
1197  case tok::l_brace:
1198  if (!tryToParseBracedList()) {
1199  // A block outside of parentheses must be the last part of a
1200  // structural element.
1201  // FIXME: Figure out cases where this is not true, and add projections
1202  // for them (the one we know is missing are lambdas).
1203  if (Style.BraceWrapping.AfterFunction)
1204  addUnwrappedLine();
1205  FormatTok->Type = TT_FunctionLBrace;
1206  parseBlock(/*MustBeDeclaration=*/false);
1207  addUnwrappedLine();
1208  return;
1209  }
1210  // Otherwise this was a braced init list, and the structural
1211  // element continues.
1212  break;
1213  case tok::kw_try:
1214  // We arrive here when parsing function-try blocks.
1215  parseTryCatch();
1216  return;
1217  case tok::identifier: {
1218  if (FormatTok->is(TT_MacroBlockEnd)) {
1219  addUnwrappedLine();
1220  return;
1221  }
1222 
1223  // Function declarations (as opposed to function expressions) are parsed
1224  // on their own unwrapped line by continuing this loop. Function
1225  // expressions (functions that are not on their own line) must not create
1226  // a new unwrapped line, so they are special cased below.
1227  size_t TokenCount = Line->Tokens.size();
1228  if (Style.Language == FormatStyle::LK_JavaScript &&
1229  FormatTok->is(Keywords.kw_function) &&
1230  (TokenCount > 1 || (TokenCount == 1 && !Line->Tokens.front().Tok->is(
1231  Keywords.kw_async)))) {
1232  tryToParseJSFunction();
1233  break;
1234  }
1235  if ((Style.Language == FormatStyle::LK_JavaScript ||
1236  Style.Language == FormatStyle::LK_Java) &&
1237  FormatTok->is(Keywords.kw_interface)) {
1238  if (Style.Language == FormatStyle::LK_JavaScript) {
1239  // In JavaScript/TypeScript, "interface" can be used as a standalone
1240  // identifier, e.g. in `var interface = 1;`. If "interface" is
1241  // followed by another identifier, it is very like to be an actual
1242  // interface declaration.
1243  unsigned StoredPosition = Tokens->getPosition();
1244  FormatToken *Next = Tokens->getNextToken();
1245  FormatTok = Tokens->setPosition(StoredPosition);
1246  if (Next && !mustBeJSIdent(Keywords, Next)) {
1247  nextToken();
1248  break;
1249  }
1250  }
1251  parseRecord();
1252  addUnwrappedLine();
1253  return;
1254  }
1255 
1256  // See if the following token should start a new unwrapped line.
1257  StringRef Text = FormatTok->TokenText;
1258  nextToken();
1259  if (Line->Tokens.size() == 1 &&
1260  // JS doesn't have macros, and within classes colons indicate fields,
1261  // not labels.
1263  if (FormatTok->Tok.is(tok::colon) && !Line->MustBeDeclaration) {
1264  Line->Tokens.begin()->Tok->MustBreakBefore = true;
1265  parseLabel();
1266  return;
1267  }
1268  // Recognize function-like macro usages without trailing semicolon as
1269  // well as free-standing macros like Q_OBJECT.
1270  bool FunctionLike = FormatTok->is(tok::l_paren);
1271  if (FunctionLike)
1272  parseParens();
1273 
1274  bool FollowedByNewline =
1275  CommentsBeforeNextToken.empty()
1276  ? FormatTok->NewlinesBefore > 0
1277  : CommentsBeforeNextToken.front()->NewlinesBefore > 0;
1278 
1279  if (FollowedByNewline && (Text.size() >= 5 || FunctionLike) &&
1280  tokenCanStartNewLine(FormatTok->Tok) && Text == Text.upper()) {
1281  addUnwrappedLine();
1282  return;
1283  }
1284  }
1285  break;
1286  }
1287  case tok::equal:
1288  // Fat arrows (=>) have tok::TokenKind tok::equal but TokenType
1289  // TT_JsFatArrow. The always start an expression or a child block if
1290  // followed by a curly.
1291  if (FormatTok->is(TT_JsFatArrow)) {
1292  nextToken();
1293  if (FormatTok->is(tok::l_brace))
1294  parseChildBlock();
1295  break;
1296  }
1297 
1298  nextToken();
1299  if (FormatTok->Tok.is(tok::l_brace)) {
1300  nextToken();
1301  parseBracedList();
1302  } else if (Style.Language == FormatStyle::LK_Proto &&
1303  FormatTok->Tok.is(tok::less)) {
1304  nextToken();
1305  parseBracedList(/*ContinueOnSemicolons=*/false,
1306  /*ClosingBraceKind=*/tok::greater);
1307  }
1308  break;
1309  case tok::l_square:
1310  parseSquare();
1311  break;
1312  case tok::kw_new:
1313  parseNew();
1314  break;
1315  default:
1316  nextToken();
1317  break;
1318  }
1319  } while (!eof());
1320 }
1321 
1322 bool UnwrappedLineParser::tryToParseLambda() {
1323  if (!Style.isCpp()) {
1324  nextToken();
1325  return false;
1326  }
1327  assert(FormatTok->is(tok::l_square));
1328  FormatToken &LSquare = *FormatTok;
1329  if (!tryToParseLambdaIntroducer())
1330  return false;
1331 
1332  while (FormatTok->isNot(tok::l_brace)) {
1333  if (FormatTok->isSimpleTypeSpecifier()) {
1334  nextToken();
1335  continue;
1336  }
1337  switch (FormatTok->Tok.getKind()) {
1338  case tok::l_brace:
1339  break;
1340  case tok::l_paren:
1341  parseParens();
1342  break;
1343  case tok::amp:
1344  case tok::star:
1345  case tok::kw_const:
1346  case tok::comma:
1347  case tok::less:
1348  case tok::greater:
1349  case tok::identifier:
1350  case tok::numeric_constant:
1351  case tok::coloncolon:
1352  case tok::kw_mutable:
1353  nextToken();
1354  break;
1355  case tok::arrow:
1356  FormatTok->Type = TT_LambdaArrow;
1357  nextToken();
1358  break;
1359  default:
1360  return true;
1361  }
1362  }
1363  LSquare.Type = TT_LambdaLSquare;
1364  parseChildBlock();
1365  return true;
1366 }
1367 
1368 bool UnwrappedLineParser::tryToParseLambdaIntroducer() {
1369  const FormatToken *Previous = FormatTok->Previous;
1370  if (Previous &&
1371  (Previous->isOneOf(tok::identifier, tok::kw_operator, tok::kw_new,
1372  tok::kw_delete) ||
1373  FormatTok->isCppStructuredBinding(Style) || Previous->closesScope() ||
1374  Previous->isSimpleTypeSpecifier())) {
1375  nextToken();
1376  return false;
1377  }
1378  nextToken();
1379  parseSquare(/*LambdaIntroducer=*/true);
1380  return true;
1381 }
1382 
1383 void UnwrappedLineParser::tryToParseJSFunction() {
1384  assert(FormatTok->is(Keywords.kw_function) ||
1385  FormatTok->startsSequence(Keywords.kw_async, Keywords.kw_function));
1386  if (FormatTok->is(Keywords.kw_async))
1387  nextToken();
1388  // Consume "function".
1389  nextToken();
1390 
1391  // Consume * (generator function). Treat it like C++'s overloaded operators.
1392  if (FormatTok->is(tok::star)) {
1393  FormatTok->Type = TT_OverloadedOperator;
1394  nextToken();
1395  }
1396 
1397  // Consume function name.
1398  if (FormatTok->is(tok::identifier))
1399  nextToken();
1400 
1401  if (FormatTok->isNot(tok::l_paren))
1402  return;
1403 
1404  // Parse formal parameter list.
1405  parseParens();
1406 
1407  if (FormatTok->is(tok::colon)) {
1408  // Parse a type definition.
1409  nextToken();
1410 
1411  // Eat the type declaration. For braced inline object types, balance braces,
1412  // otherwise just parse until finding an l_brace for the function body.
1413  if (FormatTok->is(tok::l_brace))
1414  tryToParseBracedList();
1415  else
1416  while (!FormatTok->isOneOf(tok::l_brace, tok::semi) && !eof())
1417  nextToken();
1418  }
1419 
1420  if (FormatTok->is(tok::semi))
1421  return;
1422 
1423  parseChildBlock();
1424 }
1425 
1426 bool UnwrappedLineParser::tryToParseBracedList() {
1427  if (FormatTok->BlockKind == BK_Unknown)
1428  calculateBraceTypes();
1429  assert(FormatTok->BlockKind != BK_Unknown);
1430  if (FormatTok->BlockKind == BK_Block)
1431  return false;
1432  nextToken();
1433  parseBracedList();
1434  return true;
1435 }
1436 
1437 bool UnwrappedLineParser::parseBracedList(bool ContinueOnSemicolons,
1438  tok::TokenKind ClosingBraceKind) {
1439  bool HasError = false;
1440 
1441  // FIXME: Once we have an expression parser in the UnwrappedLineParser,
1442  // replace this by using parseAssigmentExpression() inside.
1443  do {
1444  if (Style.Language == FormatStyle::LK_JavaScript) {
1445  if (FormatTok->is(Keywords.kw_function) ||
1446  FormatTok->startsSequence(Keywords.kw_async, Keywords.kw_function)) {
1447  tryToParseJSFunction();
1448  continue;
1449  }
1450  if (FormatTok->is(TT_JsFatArrow)) {
1451  nextToken();
1452  // Fat arrows can be followed by simple expressions or by child blocks
1453  // in curly braces.
1454  if (FormatTok->is(tok::l_brace)) {
1455  parseChildBlock();
1456  continue;
1457  }
1458  }
1459  if (FormatTok->is(tok::l_brace)) {
1460  // Could be a method inside of a braced list `{a() { return 1; }}`.
1461  if (tryToParseBracedList())
1462  continue;
1463  parseChildBlock();
1464  }
1465  }
1466  if (FormatTok->Tok.getKind() == ClosingBraceKind) {
1467  nextToken();
1468  return !HasError;
1469  }
1470  switch (FormatTok->Tok.getKind()) {
1471  case tok::caret:
1472  nextToken();
1473  if (FormatTok->is(tok::l_brace)) {
1474  parseChildBlock();
1475  }
1476  break;
1477  case tok::l_square:
1478  tryToParseLambda();
1479  break;
1480  case tok::l_paren:
1481  parseParens();
1482  // JavaScript can just have free standing methods and getters/setters in
1483  // object literals. Detect them by a "{" following ")".
1484  if (Style.Language == FormatStyle::LK_JavaScript) {
1485  if (FormatTok->is(tok::l_brace))
1486  parseChildBlock();
1487  break;
1488  }
1489  break;
1490  case tok::l_brace:
1491  // Assume there are no blocks inside a braced init list apart
1492  // from the ones we explicitly parse out (like lambdas).
1493  FormatTok->BlockKind = BK_BracedInit;
1494  nextToken();
1495  parseBracedList();
1496  break;
1497  case tok::less:
1498  if (Style.Language == FormatStyle::LK_Proto) {
1499  nextToken();
1500  parseBracedList(/*ContinueOnSemicolons=*/false,
1501  /*ClosingBraceKind=*/tok::greater);
1502  } else {
1503  nextToken();
1504  }
1505  break;
1506  case tok::semi:
1507  // JavaScript (or more precisely TypeScript) can have semicolons in braced
1508  // lists (in so-called TypeMemberLists). Thus, the semicolon cannot be
1509  // used for error recovery if we have otherwise determined that this is
1510  // a braced list.
1511  if (Style.Language == FormatStyle::LK_JavaScript) {
1512  nextToken();
1513  break;
1514  }
1515  HasError = true;
1516  if (!ContinueOnSemicolons)
1517  return !HasError;
1518  nextToken();
1519  break;
1520  case tok::comma:
1521  nextToken();
1522  break;
1523  default:
1524  nextToken();
1525  break;
1526  }
1527  } while (!eof());
1528  return false;
1529 }
1530 
1531 void UnwrappedLineParser::parseParens() {
1532  assert(FormatTok->Tok.is(tok::l_paren) && "'(' expected.");
1533  nextToken();
1534  do {
1535  switch (FormatTok->Tok.getKind()) {
1536  case tok::l_paren:
1537  parseParens();
1538  if (Style.Language == FormatStyle::LK_Java && FormatTok->is(tok::l_brace))
1539  parseChildBlock();
1540  break;
1541  case tok::r_paren:
1542  nextToken();
1543  return;
1544  case tok::r_brace:
1545  // A "}" inside parenthesis is an error if there wasn't a matching "{".
1546  return;
1547  case tok::l_square:
1548  tryToParseLambda();
1549  break;
1550  case tok::l_brace:
1551  if (!tryToParseBracedList())
1552  parseChildBlock();
1553  break;
1554  case tok::at:
1555  nextToken();
1556  if (FormatTok->Tok.is(tok::l_brace)) {
1557  nextToken();
1558  parseBracedList();
1559  }
1560  break;
1561  case tok::kw_class:
1562  if (Style.Language == FormatStyle::LK_JavaScript)
1563  parseRecord(/*ParseAsExpr=*/true);
1564  else
1565  nextToken();
1566  break;
1567  case tok::identifier:
1568  if (Style.Language == FormatStyle::LK_JavaScript &&
1569  (FormatTok->is(Keywords.kw_function) ||
1570  FormatTok->startsSequence(Keywords.kw_async, Keywords.kw_function)))
1571  tryToParseJSFunction();
1572  else
1573  nextToken();
1574  break;
1575  default:
1576  nextToken();
1577  break;
1578  }
1579  } while (!eof());
1580 }
1581 
1582 void UnwrappedLineParser::parseSquare(bool LambdaIntroducer) {
1583  if (!LambdaIntroducer) {
1584  assert(FormatTok->Tok.is(tok::l_square) && "'[' expected.");
1585  if (tryToParseLambda())
1586  return;
1587  }
1588  do {
1589  switch (FormatTok->Tok.getKind()) {
1590  case tok::l_paren:
1591  parseParens();
1592  break;
1593  case tok::r_square:
1594  nextToken();
1595  return;
1596  case tok::r_brace:
1597  // A "}" inside parenthesis is an error if there wasn't a matching "{".
1598  return;
1599  case tok::l_square:
1600  parseSquare();
1601  break;
1602  case tok::l_brace: {
1603  if (!tryToParseBracedList())
1604  parseChildBlock();
1605  break;
1606  }
1607  case tok::at:
1608  nextToken();
1609  if (FormatTok->Tok.is(tok::l_brace)) {
1610  nextToken();
1611  parseBracedList();
1612  }
1613  break;
1614  default:
1615  nextToken();
1616  break;
1617  }
1618  } while (!eof());
1619 }
1620 
1621 void UnwrappedLineParser::parseIfThenElse() {
1622  assert(FormatTok->Tok.is(tok::kw_if) && "'if' expected");
1623  nextToken();
1624  if (FormatTok->Tok.is(tok::kw_constexpr))
1625  nextToken();
1626  if (FormatTok->Tok.is(tok::l_paren))
1627  parseParens();
1628  bool NeedsUnwrappedLine = false;
1629  if (FormatTok->Tok.is(tok::l_brace)) {
1630  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1631  parseBlock(/*MustBeDeclaration=*/false);
1632  if (Style.BraceWrapping.BeforeElse)
1633  addUnwrappedLine();
1634  else
1635  NeedsUnwrappedLine = true;
1636  } else {
1637  addUnwrappedLine();
1638  ++Line->Level;
1639  parseStructuralElement();
1640  --Line->Level;
1641  }
1642  if (FormatTok->Tok.is(tok::kw_else)) {
1643  nextToken();
1644  if (FormatTok->Tok.is(tok::l_brace)) {
1645  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1646  parseBlock(/*MustBeDeclaration=*/false);
1647  addUnwrappedLine();
1648  } else if (FormatTok->Tok.is(tok::kw_if)) {
1649  parseIfThenElse();
1650  } else {
1651  addUnwrappedLine();
1652  ++Line->Level;
1653  parseStructuralElement();
1654  if (FormatTok->is(tok::eof))
1655  addUnwrappedLine();
1656  --Line->Level;
1657  }
1658  } else if (NeedsUnwrappedLine) {
1659  addUnwrappedLine();
1660  }
1661 }
1662 
1663 void UnwrappedLineParser::parseTryCatch() {
1664  assert(FormatTok->isOneOf(tok::kw_try, tok::kw___try) && "'try' expected");
1665  nextToken();
1666  bool NeedsUnwrappedLine = false;
1667  if (FormatTok->is(tok::colon)) {
1668  // We are in a function try block, what comes is an initializer list.
1669  nextToken();
1670  while (FormatTok->is(tok::identifier)) {
1671  nextToken();
1672  if (FormatTok->is(tok::l_paren))
1673  parseParens();
1674  if (FormatTok->is(tok::comma))
1675  nextToken();
1676  }
1677  }
1678  // Parse try with resource.
1679  if (Style.Language == FormatStyle::LK_Java && FormatTok->is(tok::l_paren)) {
1680  parseParens();
1681  }
1682  if (FormatTok->is(tok::l_brace)) {
1683  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1684  parseBlock(/*MustBeDeclaration=*/false);
1685  if (Style.BraceWrapping.BeforeCatch) {
1686  addUnwrappedLine();
1687  } else {
1688  NeedsUnwrappedLine = true;
1689  }
1690  } else if (!FormatTok->is(tok::kw_catch)) {
1691  // The C++ standard requires a compound-statement after a try.
1692  // If there's none, we try to assume there's a structuralElement
1693  // and try to continue.
1694  addUnwrappedLine();
1695  ++Line->Level;
1696  parseStructuralElement();
1697  --Line->Level;
1698  }
1699  while (1) {
1700  if (FormatTok->is(tok::at))
1701  nextToken();
1702  if (!(FormatTok->isOneOf(tok::kw_catch, Keywords.kw___except,
1703  tok::kw___finally) ||
1704  ((Style.Language == FormatStyle::LK_Java ||
1706  FormatTok->is(Keywords.kw_finally)) ||
1707  (FormatTok->Tok.isObjCAtKeyword(tok::objc_catch) ||
1708  FormatTok->Tok.isObjCAtKeyword(tok::objc_finally))))
1709  break;
1710  nextToken();
1711  while (FormatTok->isNot(tok::l_brace)) {
1712  if (FormatTok->is(tok::l_paren)) {
1713  parseParens();
1714  continue;
1715  }
1716  if (FormatTok->isOneOf(tok::semi, tok::r_brace, tok::eof))
1717  return;
1718  nextToken();
1719  }
1720  NeedsUnwrappedLine = false;
1721  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1722  parseBlock(/*MustBeDeclaration=*/false);
1723  if (Style.BraceWrapping.BeforeCatch)
1724  addUnwrappedLine();
1725  else
1726  NeedsUnwrappedLine = true;
1727  }
1728  if (NeedsUnwrappedLine)
1729  addUnwrappedLine();
1730 }
1731 
1732 void UnwrappedLineParser::parseNamespace() {
1733  assert(FormatTok->Tok.is(tok::kw_namespace) && "'namespace' expected");
1734 
1735  const FormatToken &InitialToken = *FormatTok;
1736  nextToken();
1737  while (FormatTok->isOneOf(tok::identifier, tok::coloncolon))
1738  nextToken();
1739  if (FormatTok->Tok.is(tok::l_brace)) {
1740  if (ShouldBreakBeforeBrace(Style, InitialToken))
1741  addUnwrappedLine();
1742 
1743  bool AddLevel = Style.NamespaceIndentation == FormatStyle::NI_All ||
1745  DeclarationScopeStack.size() > 1);
1746  parseBlock(/*MustBeDeclaration=*/true, AddLevel);
1747  // Munch the semicolon after a namespace. This is more common than one would
1748  // think. Puttin the semicolon into its own line is very ugly.
1749  if (FormatTok->Tok.is(tok::semi))
1750  nextToken();
1751  addUnwrappedLine();
1752  }
1753  // FIXME: Add error handling.
1754 }
1755 
1756 void UnwrappedLineParser::parseNew() {
1757  assert(FormatTok->is(tok::kw_new) && "'new' expected");
1758  nextToken();
1759  if (Style.Language != FormatStyle::LK_Java)
1760  return;
1761 
1762  // In Java, we can parse everything up to the parens, which aren't optional.
1763  do {
1764  // There should not be a ;, { or } before the new's open paren.
1765  if (FormatTok->isOneOf(tok::semi, tok::l_brace, tok::r_brace))
1766  return;
1767 
1768  // Consume the parens.
1769  if (FormatTok->is(tok::l_paren)) {
1770  parseParens();
1771 
1772  // If there is a class body of an anonymous class, consume that as child.
1773  if (FormatTok->is(tok::l_brace))
1774  parseChildBlock();
1775  return;
1776  }
1777  nextToken();
1778  } while (!eof());
1779 }
1780 
1781 void UnwrappedLineParser::parseForOrWhileLoop() {
1782  assert(FormatTok->isOneOf(tok::kw_for, tok::kw_while, TT_ForEachMacro) &&
1783  "'for', 'while' or foreach macro expected");
1784  nextToken();
1785  // JS' for await ( ...
1786  if (Style.Language == FormatStyle::LK_JavaScript &&
1787  FormatTok->is(Keywords.kw_await))
1788  nextToken();
1789  if (FormatTok->Tok.is(tok::l_paren))
1790  parseParens();
1791  if (FormatTok->Tok.is(tok::l_brace)) {
1792  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1793  parseBlock(/*MustBeDeclaration=*/false);
1794  addUnwrappedLine();
1795  } else {
1796  addUnwrappedLine();
1797  ++Line->Level;
1798  parseStructuralElement();
1799  --Line->Level;
1800  }
1801 }
1802 
1803 void UnwrappedLineParser::parseDoWhile() {
1804  assert(FormatTok->Tok.is(tok::kw_do) && "'do' expected");
1805  nextToken();
1806  if (FormatTok->Tok.is(tok::l_brace)) {
1807  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1808  parseBlock(/*MustBeDeclaration=*/false);
1809  if (Style.BraceWrapping.IndentBraces)
1810  addUnwrappedLine();
1811  } else {
1812  addUnwrappedLine();
1813  ++Line->Level;
1814  parseStructuralElement();
1815  --Line->Level;
1816  }
1817 
1818  // FIXME: Add error handling.
1819  if (!FormatTok->Tok.is(tok::kw_while)) {
1820  addUnwrappedLine();
1821  return;
1822  }
1823 
1824  nextToken();
1825  parseStructuralElement();
1826 }
1827 
1828 void UnwrappedLineParser::parseLabel() {
1829  nextToken();
1830  unsigned OldLineLevel = Line->Level;
1831  if (Line->Level > 1 || (!Line->InPPDirective && Line->Level > 0))
1832  --Line->Level;
1833  if (CommentsBeforeNextToken.empty() && FormatTok->Tok.is(tok::l_brace)) {
1834  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1835  parseBlock(/*MustBeDeclaration=*/false);
1836  if (FormatTok->Tok.is(tok::kw_break)) {
1838  addUnwrappedLine();
1839  parseStructuralElement();
1840  }
1841  addUnwrappedLine();
1842  } else {
1843  if (FormatTok->is(tok::semi))
1844  nextToken();
1845  addUnwrappedLine();
1846  }
1847  Line->Level = OldLineLevel;
1848  if (FormatTok->isNot(tok::l_brace)) {
1849  parseStructuralElement();
1850  addUnwrappedLine();
1851  }
1852 }
1853 
1854 void UnwrappedLineParser::parseCaseLabel() {
1855  assert(FormatTok->Tok.is(tok::kw_case) && "'case' expected");
1856  // FIXME: fix handling of complex expressions here.
1857  do {
1858  nextToken();
1859  } while (!eof() && !FormatTok->Tok.is(tok::colon));
1860  parseLabel();
1861 }
1862 
1863 void UnwrappedLineParser::parseSwitch() {
1864  assert(FormatTok->Tok.is(tok::kw_switch) && "'switch' expected");
1865  nextToken();
1866  if (FormatTok->Tok.is(tok::l_paren))
1867  parseParens();
1868  if (FormatTok->Tok.is(tok::l_brace)) {
1869  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1870  parseBlock(/*MustBeDeclaration=*/false);
1871  addUnwrappedLine();
1872  } else {
1873  addUnwrappedLine();
1874  ++Line->Level;
1875  parseStructuralElement();
1876  --Line->Level;
1877  }
1878 }
1879 
1880 void UnwrappedLineParser::parseAccessSpecifier() {
1881  nextToken();
1882  // Understand Qt's slots.
1883  if (FormatTok->isOneOf(Keywords.kw_slots, Keywords.kw_qslots))
1884  nextToken();
1885  // Otherwise, we don't know what it is, and we'd better keep the next token.
1886  if (FormatTok->Tok.is(tok::colon))
1887  nextToken();
1888  addUnwrappedLine();
1889 }
1890 
1891 bool UnwrappedLineParser::parseEnum() {
1892  // Won't be 'enum' for NS_ENUMs.
1893  if (FormatTok->Tok.is(tok::kw_enum))
1894  nextToken();
1895 
1896  // In TypeScript, "enum" can also be used as property name, e.g. in interface
1897  // declarations. An "enum" keyword followed by a colon would be a syntax
1898  // error and thus assume it is just an identifier.
1899  if (Style.Language == FormatStyle::LK_JavaScript &&
1900  FormatTok->isOneOf(tok::colon, tok::question))
1901  return false;
1902 
1903  // Eat up enum class ...
1904  if (FormatTok->Tok.is(tok::kw_class) || FormatTok->Tok.is(tok::kw_struct))
1905  nextToken();
1906 
1907  while (FormatTok->Tok.getIdentifierInfo() ||
1908  FormatTok->isOneOf(tok::colon, tok::coloncolon, tok::less,
1909  tok::greater, tok::comma, tok::question)) {
1910  nextToken();
1911  // We can have macros or attributes in between 'enum' and the enum name.
1912  if (FormatTok->is(tok::l_paren))
1913  parseParens();
1914  if (FormatTok->is(tok::identifier)) {
1915  nextToken();
1916  // If there are two identifiers in a row, this is likely an elaborate
1917  // return type. In Java, this can be "implements", etc.
1918  if (Style.isCpp() && FormatTok->is(tok::identifier))
1919  return false;
1920  }
1921  }
1922 
1923  // Just a declaration or something is wrong.
1924  if (FormatTok->isNot(tok::l_brace))
1925  return true;
1926  FormatTok->BlockKind = BK_Block;
1927 
1928  if (Style.Language == FormatStyle::LK_Java) {
1929  // Java enums are different.
1930  parseJavaEnumBody();
1931  return true;
1932  }
1933  if (Style.Language == FormatStyle::LK_Proto) {
1934  parseBlock(/*MustBeDeclaration=*/true);
1935  return true;
1936  }
1937 
1938  // Parse enum body.
1939  nextToken();
1940  bool HasError = !parseBracedList(/*ContinueOnSemicolons=*/true);
1941  if (HasError) {
1942  if (FormatTok->is(tok::semi))
1943  nextToken();
1944  addUnwrappedLine();
1945  }
1946  return true;
1947 
1948  // There is no addUnwrappedLine() here so that we fall through to parsing a
1949  // structural element afterwards. Thus, in "enum A {} n, m;",
1950  // "} n, m;" will end up in one unwrapped line.
1951 }
1952 
1953 void UnwrappedLineParser::parseJavaEnumBody() {
1954  // Determine whether the enum is simple, i.e. does not have a semicolon or
1955  // constants with class bodies. Simple enums can be formatted like braced
1956  // lists, contracted to a single line, etc.
1957  unsigned StoredPosition = Tokens->getPosition();
1958  bool IsSimple = true;
1959  FormatToken *Tok = Tokens->getNextToken();
1960  while (Tok) {
1961  if (Tok->is(tok::r_brace))
1962  break;
1963  if (Tok->isOneOf(tok::l_brace, tok::semi)) {
1964  IsSimple = false;
1965  break;
1966  }
1967  // FIXME: This will also mark enums with braces in the arguments to enum
1968  // constants as "not simple". This is probably fine in practice, though.
1969  Tok = Tokens->getNextToken();
1970  }
1971  FormatTok = Tokens->setPosition(StoredPosition);
1972 
1973  if (IsSimple) {
1974  nextToken();
1975  parseBracedList();
1976  addUnwrappedLine();
1977  return;
1978  }
1979 
1980  // Parse the body of a more complex enum.
1981  // First add a line for everything up to the "{".
1982  nextToken();
1983  addUnwrappedLine();
1984  ++Line->Level;
1985 
1986  // Parse the enum constants.
1987  while (FormatTok) {
1988  if (FormatTok->is(tok::l_brace)) {
1989  // Parse the constant's class body.
1990  parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/true,
1991  /*MunchSemi=*/false);
1992  } else if (FormatTok->is(tok::l_paren)) {
1993  parseParens();
1994  } else if (FormatTok->is(tok::comma)) {
1995  nextToken();
1996  addUnwrappedLine();
1997  } else if (FormatTok->is(tok::semi)) {
1998  nextToken();
1999  addUnwrappedLine();
2000  break;
2001  } else if (FormatTok->is(tok::r_brace)) {
2002  addUnwrappedLine();
2003  break;
2004  } else {
2005  nextToken();
2006  }
2007  }
2008 
2009  // Parse the class body after the enum's ";" if any.
2010  parseLevel(/*HasOpeningBrace=*/true);
2011  nextToken();
2012  --Line->Level;
2013  addUnwrappedLine();
2014 }
2015 
2016 void UnwrappedLineParser::parseRecord(bool ParseAsExpr) {
2017  const FormatToken &InitialToken = *FormatTok;
2018  nextToken();
2019 
2020  // The actual identifier can be a nested name specifier, and in macros
2021  // it is often token-pasted.
2022  while (FormatTok->isOneOf(tok::identifier, tok::coloncolon, tok::hashhash,
2023  tok::kw___attribute, tok::kw___declspec,
2024  tok::kw_alignas) ||
2025  ((Style.Language == FormatStyle::LK_Java ||
2027  FormatTok->isOneOf(tok::period, tok::comma))) {
2028  if (Style.Language == FormatStyle::LK_JavaScript &&
2029  FormatTok->isOneOf(Keywords.kw_extends, Keywords.kw_implements)) {
2030  // JavaScript/TypeScript supports inline object types in
2031  // extends/implements positions:
2032  // class Foo implements {bar: number} { }
2033  nextToken();
2034  if (FormatTok->is(tok::l_brace)) {
2035  tryToParseBracedList();
2036  continue;
2037  }
2038  }
2039  bool IsNonMacroIdentifier =
2040  FormatTok->is(tok::identifier) &&
2041  FormatTok->TokenText != FormatTok->TokenText.upper();
2042  nextToken();
2043  // We can have macros or attributes in between 'class' and the class name.
2044  if (!IsNonMacroIdentifier && FormatTok->Tok.is(tok::l_paren))
2045  parseParens();
2046  }
2047 
2048  // Note that parsing away template declarations here leads to incorrectly
2049  // accepting function declarations as record declarations.
2050  // In general, we cannot solve this problem. Consider:
2051  // class A<int> B() {}
2052  // which can be a function definition or a class definition when B() is a
2053  // macro. If we find enough real-world cases where this is a problem, we
2054  // can parse for the 'template' keyword in the beginning of the statement,
2055  // and thus rule out the record production in case there is no template
2056  // (this would still leave us with an ambiguity between template function
2057  // and class declarations).
2058  if (FormatTok->isOneOf(tok::colon, tok::less)) {
2059  while (!eof()) {
2060  if (FormatTok->is(tok::l_brace)) {
2061  calculateBraceTypes(/*ExpectClassBody=*/true);
2062  if (!tryToParseBracedList())
2063  break;
2064  }
2065  if (FormatTok->Tok.is(tok::semi))
2066  return;
2067  nextToken();
2068  }
2069  }
2070  if (FormatTok->Tok.is(tok::l_brace)) {
2071  if (ParseAsExpr) {
2072  parseChildBlock();
2073  } else {
2074  if (ShouldBreakBeforeBrace(Style, InitialToken))
2075  addUnwrappedLine();
2076 
2077  parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/true,
2078  /*MunchSemi=*/false);
2079  }
2080  }
2081  // There is no addUnwrappedLine() here so that we fall through to parsing a
2082  // structural element afterwards. Thus, in "class A {} n, m;",
2083  // "} n, m;" will end up in one unwrapped line.
2084 }
2085 
2086 void UnwrappedLineParser::parseObjCProtocolList() {
2087  assert(FormatTok->Tok.is(tok::less) && "'<' expected.");
2088  do
2089  nextToken();
2090  while (!eof() && FormatTok->Tok.isNot(tok::greater));
2091  nextToken(); // Skip '>'.
2092 }
2093 
2094 void UnwrappedLineParser::parseObjCUntilAtEnd() {
2095  do {
2096  if (FormatTok->Tok.isObjCAtKeyword(tok::objc_end)) {
2097  nextToken();
2098  addUnwrappedLine();
2099  break;
2100  }
2101  if (FormatTok->is(tok::l_brace)) {
2102  parseBlock(/*MustBeDeclaration=*/false);
2103  // In ObjC interfaces, nothing should be following the "}".
2104  addUnwrappedLine();
2105  } else if (FormatTok->is(tok::r_brace)) {
2106  // Ignore stray "}". parseStructuralElement doesn't consume them.
2107  nextToken();
2108  addUnwrappedLine();
2109  } else {
2110  parseStructuralElement();
2111  }
2112  } while (!eof());
2113 }
2114 
2115 void UnwrappedLineParser::parseObjCInterfaceOrImplementation() {
2116  nextToken();
2117  nextToken(); // interface name
2118 
2119  // @interface can be followed by either a base class, or a category.
2120  if (FormatTok->Tok.is(tok::colon)) {
2121  nextToken();
2122  nextToken(); // base class name
2123  } else if (FormatTok->Tok.is(tok::l_paren))
2124  // Skip category, if present.
2125  parseParens();
2126 
2127  if (FormatTok->Tok.is(tok::less))
2128  parseObjCProtocolList();
2129 
2130  if (FormatTok->Tok.is(tok::l_brace)) {
2132  addUnwrappedLine();
2133  parseBlock(/*MustBeDeclaration=*/true);
2134  }
2135 
2136  // With instance variables, this puts '}' on its own line. Without instance
2137  // variables, this ends the @interface line.
2138  addUnwrappedLine();
2139 
2140  parseObjCUntilAtEnd();
2141 }
2142 
2143 void UnwrappedLineParser::parseObjCProtocol() {
2144  nextToken();
2145  nextToken(); // protocol name
2146 
2147  if (FormatTok->Tok.is(tok::less))
2148  parseObjCProtocolList();
2149 
2150  // Check for protocol declaration.
2151  if (FormatTok->Tok.is(tok::semi)) {
2152  nextToken();
2153  return addUnwrappedLine();
2154  }
2155 
2156  addUnwrappedLine();
2157  parseObjCUntilAtEnd();
2158 }
2159 
2160 void UnwrappedLineParser::parseJavaScriptEs6ImportExport() {
2161  bool IsImport = FormatTok->is(Keywords.kw_import);
2162  assert(IsImport || FormatTok->is(tok::kw_export));
2163  nextToken();
2164 
2165  // Consume the "default" in "export default class/function".
2166  if (FormatTok->is(tok::kw_default))
2167  nextToken();
2168 
2169  // Consume "async function", "function" and "default function", so that these
2170  // get parsed as free-standing JS functions, i.e. do not require a trailing
2171  // semicolon.
2172  if (FormatTok->is(Keywords.kw_async))
2173  nextToken();
2174  if (FormatTok->is(Keywords.kw_function)) {
2175  nextToken();
2176  return;
2177  }
2178 
2179  // For imports, `export *`, `export {...}`, consume the rest of the line up
2180  // to the terminating `;`. For everything else, just return and continue
2181  // parsing the structural element, i.e. the declaration or expression for
2182  // `export default`.
2183  if (!IsImport && !FormatTok->isOneOf(tok::l_brace, tok::star) &&
2184  !FormatTok->isStringLiteral())
2185  return;
2186 
2187  while (!eof()) {
2188  if (FormatTok->is(tok::semi))
2189  return;
2190  if (Line->Tokens.empty()) {
2191  // Common issue: Automatic Semicolon Insertion wrapped the line, so the
2192  // import statement should terminate.
2193  return;
2194  }
2195  if (FormatTok->is(tok::l_brace)) {
2196  FormatTok->BlockKind = BK_Block;
2197  nextToken();
2198  parseBracedList();
2199  } else {
2200  nextToken();
2201  }
2202  }
2203 }
2204 
2205 LLVM_ATTRIBUTE_UNUSED static void printDebugInfo(const UnwrappedLine &Line,
2206  StringRef Prefix = "") {
2207  llvm::dbgs() << Prefix << "Line(" << Line.Level
2208  << ", FSC=" << Line.FirstStartColumn << ")"
2209  << (Line.InPPDirective ? " MACRO" : "") << ": ";
2210  for (std::list<UnwrappedLineNode>::const_iterator I = Line.Tokens.begin(),
2211  E = Line.Tokens.end();
2212  I != E; ++I) {
2213  llvm::dbgs() << I->Tok->Tok.getName() << "["
2214  << "T=" << I->Tok->Type << ", OC=" << I->Tok->OriginalColumn
2215  << "] ";
2216  }
2217  for (std::list<UnwrappedLineNode>::const_iterator I = Line.Tokens.begin(),
2218  E = Line.Tokens.end();
2219  I != E; ++I) {
2220  const UnwrappedLineNode &Node = *I;
2222  I = Node.Children.begin(),
2223  E = Node.Children.end();
2224  I != E; ++I) {
2225  printDebugInfo(*I, "\nChild: ");
2226  }
2227  }
2228  llvm::dbgs() << "\n";
2229 }
2230 
2231 void UnwrappedLineParser::addUnwrappedLine() {
2232  if (Line->Tokens.empty())
2233  return;
2234  DEBUG({
2235  if (CurrentLines == &Lines)
2236  printDebugInfo(*Line);
2237  });
2238  CurrentLines->push_back(std::move(*Line));
2239  Line->Tokens.clear();
2240  Line->MatchingOpeningBlockLineIndex = UnwrappedLine::kInvalidIndex;
2241  Line->FirstStartColumn = 0;
2242  if (CurrentLines == &Lines && !PreprocessorDirectives.empty()) {
2243  CurrentLines->append(
2244  std::make_move_iterator(PreprocessorDirectives.begin()),
2245  std::make_move_iterator(PreprocessorDirectives.end()));
2246  PreprocessorDirectives.clear();
2247  }
2248  // Disconnect the current token from the last token on the previous line.
2249  FormatTok->Previous = nullptr;
2250 }
2251 
2252 bool UnwrappedLineParser::eof() const { return FormatTok->Tok.is(tok::eof); }
2253 
2254 bool UnwrappedLineParser::isOnNewLine(const FormatToken &FormatTok) {
2255  return (Line->InPPDirective || FormatTok.HasUnescapedNewline) &&
2256  FormatTok.NewlinesBefore > 0;
2257 }
2258 
2259 // Checks if \p FormatTok is a line comment that continues the line comment
2260 // section on \p Line.
2261 static bool continuesLineCommentSection(const FormatToken &FormatTok,
2262  const UnwrappedLine &Line,
2263  llvm::Regex &CommentPragmasRegex) {
2264  if (Line.Tokens.empty())
2265  return false;
2266 
2267  StringRef IndentContent = FormatTok.TokenText;
2268  if (FormatTok.TokenText.startswith("//") ||
2269  FormatTok.TokenText.startswith("/*"))
2270  IndentContent = FormatTok.TokenText.substr(2);
2271  if (CommentPragmasRegex.match(IndentContent))
2272  return false;
2273 
2274  // If Line starts with a line comment, then FormatTok continues the comment
2275  // section if its original column is greater or equal to the original start
2276  // column of the line.
2277  //
2278  // Define the min column token of a line as follows: if a line ends in '{' or
2279  // contains a '{' followed by a line comment, then the min column token is
2280  // that '{'. Otherwise, the min column token of the line is the first token of
2281  // the line.
2282  //
2283  // If Line starts with a token other than a line comment, then FormatTok
2284  // continues the comment section if its original column is greater than the
2285  // original start column of the min column token of the line.
2286  //
2287  // For example, the second line comment continues the first in these cases:
2288  //
2289  // // first line
2290  // // second line
2291  //
2292  // and:
2293  //
2294  // // first line
2295  // // second line
2296  //
2297  // and:
2298  //
2299  // int i; // first line
2300  // // second line
2301  //
2302  // and:
2303  //
2304  // do { // first line
2305  // // second line
2306  // int i;
2307  // } while (true);
2308  //
2309  // and:
2310  //
2311  // enum {
2312  // a, // first line
2313  // // second line
2314  // b
2315  // };
2316  //
2317  // The second line comment doesn't continue the first in these cases:
2318  //
2319  // // first line
2320  // // second line
2321  //
2322  // and:
2323  //
2324  // int i; // first line
2325  // // second line
2326  //
2327  // and:
2328  //
2329  // do { // first line
2330  // // second line
2331  // int i;
2332  // } while (true);
2333  //
2334  // and:
2335  //
2336  // enum {
2337  // a, // first line
2338  // // second line
2339  // };
2340  const FormatToken *MinColumnToken = Line.Tokens.front().Tok;
2341 
2342  // Scan for '{//'. If found, use the column of '{' as a min column for line
2343  // comment section continuation.
2344  const FormatToken *PreviousToken = nullptr;
2345  for (const UnwrappedLineNode &Node : Line.Tokens) {
2346  if (PreviousToken && PreviousToken->is(tok::l_brace) &&
2347  isLineComment(*Node.Tok)) {
2348  MinColumnToken = PreviousToken;
2349  break;
2350  }
2351  PreviousToken = Node.Tok;
2352 
2353  // Grab the last newline preceding a token in this unwrapped line.
2354  if (Node.Tok->NewlinesBefore > 0) {
2355  MinColumnToken = Node.Tok;
2356  }
2357  }
2358  if (PreviousToken && PreviousToken->is(tok::l_brace)) {
2359  MinColumnToken = PreviousToken;
2360  }
2361 
2362  return continuesLineComment(FormatTok, /*Previous=*/Line.Tokens.back().Tok,
2363  MinColumnToken);
2364 }
2365 
2366 void UnwrappedLineParser::flushComments(bool NewlineBeforeNext) {
2367  bool JustComments = Line->Tokens.empty();
2369  I = CommentsBeforeNextToken.begin(),
2370  E = CommentsBeforeNextToken.end();
2371  I != E; ++I) {
2372  // Line comments that belong to the same line comment section are put on the
2373  // same line since later we might want to reflow content between them.
2374  // Additional fine-grained breaking of line comment sections is controlled
2375  // by the class BreakableLineCommentSection in case it is desirable to keep
2376  // several line comment sections in the same unwrapped line.
2377  //
2378  // FIXME: Consider putting separate line comment sections as children to the
2379  // unwrapped line instead.
2381  continuesLineCommentSection(**I, *Line, CommentPragmasRegex);
2382  if (isOnNewLine(**I) && JustComments && !(*I)->ContinuesLineCommentSection)
2383  addUnwrappedLine();
2384  pushToken(*I);
2385  }
2386  if (NewlineBeforeNext && JustComments)
2387  addUnwrappedLine();
2388  CommentsBeforeNextToken.clear();
2389 }
2390 
2391 void UnwrappedLineParser::nextToken(int LevelDifference) {
2392  if (eof())
2393  return;
2394  flushComments(isOnNewLine(*FormatTok));
2395  pushToken(FormatTok);
2396  FormatToken *Previous = FormatTok;
2397  if (Style.Language != FormatStyle::LK_JavaScript)
2398  readToken(LevelDifference);
2399  else
2400  readTokenWithJavaScriptASI();
2401  FormatTok->Previous = Previous;
2402 }
2403 
2404 void UnwrappedLineParser::distributeComments(
2405  const SmallVectorImpl<FormatToken *> &Comments,
2406  const FormatToken *NextTok) {
2407  // Whether or not a line comment token continues a line is controlled by
2408  // the method continuesLineCommentSection, with the following caveat:
2409  //
2410  // Define a trail of Comments to be a nonempty proper postfix of Comments such
2411  // that each comment line from the trail is aligned with the next token, if
2412  // the next token exists. If a trail exists, the beginning of the maximal
2413  // trail is marked as a start of a new comment section.
2414  //
2415  // For example in this code:
2416  //
2417  // int a; // line about a
2418  // // line 1 about b
2419  // // line 2 about b
2420  // int b;
2421  //
2422  // the two lines about b form a maximal trail, so there are two sections, the
2423  // first one consisting of the single comment "// line about a" and the
2424  // second one consisting of the next two comments.
2425  if (Comments.empty())
2426  return;
2427  bool ShouldPushCommentsInCurrentLine = true;
2428  bool HasTrailAlignedWithNextToken = false;
2429  unsigned StartOfTrailAlignedWithNextToken = 0;
2430  if (NextTok) {
2431  // We are skipping the first element intentionally.
2432  for (unsigned i = Comments.size() - 1; i > 0; --i) {
2433  if (Comments[i]->OriginalColumn == NextTok->OriginalColumn) {
2434  HasTrailAlignedWithNextToken = true;
2435  StartOfTrailAlignedWithNextToken = i;
2436  }
2437  }
2438  }
2439  for (unsigned i = 0, e = Comments.size(); i < e; ++i) {
2440  FormatToken *FormatTok = Comments[i];
2441  if (HasTrailAlignedWithNextToken && i == StartOfTrailAlignedWithNextToken) {
2442  FormatTok->ContinuesLineCommentSection = false;
2443  } else {
2444  FormatTok->ContinuesLineCommentSection =
2445  continuesLineCommentSection(*FormatTok, *Line, CommentPragmasRegex);
2446  }
2447  if (!FormatTok->ContinuesLineCommentSection &&
2448  (isOnNewLine(*FormatTok) || FormatTok->IsFirst)) {
2449  ShouldPushCommentsInCurrentLine = false;
2450  }
2451  if (ShouldPushCommentsInCurrentLine) {
2452  pushToken(FormatTok);
2453  } else {
2454  CommentsBeforeNextToken.push_back(FormatTok);
2455  }
2456  }
2457 }
2458 
2459 void UnwrappedLineParser::readToken(int LevelDifference) {
2461  do {
2462  FormatTok = Tokens->getNextToken();
2463  assert(FormatTok);
2464  while (!Line->InPPDirective && FormatTok->Tok.is(tok::hash) &&
2465  (FormatTok->HasUnescapedNewline || FormatTok->IsFirst)) {
2466  distributeComments(Comments, FormatTok);
2467  Comments.clear();
2468  // If there is an unfinished unwrapped line, we flush the preprocessor
2469  // directives only after that unwrapped line was finished later.
2470  bool SwitchToPreprocessorLines = !Line->Tokens.empty();
2471  ScopedLineState BlockState(*this, SwitchToPreprocessorLines);
2472  assert((LevelDifference >= 0 ||
2473  static_cast<unsigned>(-LevelDifference) <= Line->Level) &&
2474  "LevelDifference makes Line->Level negative");
2475  Line->Level += LevelDifference;
2476  // Comments stored before the preprocessor directive need to be output
2477  // before the preprocessor directive, at the same level as the
2478  // preprocessor directive, as we consider them to apply to the directive.
2479  flushComments(isOnNewLine(*FormatTok));
2480  parsePPDirective();
2481  }
2482  while (FormatTok->Type == TT_ConflictStart ||
2483  FormatTok->Type == TT_ConflictEnd ||
2484  FormatTok->Type == TT_ConflictAlternative) {
2485  if (FormatTok->Type == TT_ConflictStart) {
2486  conditionalCompilationStart(/*Unreachable=*/false);
2487  } else if (FormatTok->Type == TT_ConflictAlternative) {
2488  conditionalCompilationAlternative();
2489  } else if (FormatTok->Type == TT_ConflictEnd) {
2490  conditionalCompilationEnd();
2491  }
2492  FormatTok = Tokens->getNextToken();
2493  FormatTok->MustBreakBefore = true;
2494  }
2495 
2496  if (!PPStack.empty() && (PPStack.back().Kind == PP_Unreachable) &&
2497  !Line->InPPDirective) {
2498  continue;
2499  }
2500 
2501  if (!FormatTok->Tok.is(tok::comment)) {
2502  distributeComments(Comments, FormatTok);
2503  Comments.clear();
2504  return;
2505  }
2506 
2507  Comments.push_back(FormatTok);
2508  } while (!eof());
2509 
2510  distributeComments(Comments, nullptr);
2511  Comments.clear();
2512 }
2513 
2514 void UnwrappedLineParser::pushToken(FormatToken *Tok) {
2515  Line->Tokens.push_back(UnwrappedLineNode(Tok));
2516  if (MustBreakBeforeNextToken) {
2517  Line->Tokens.back().Tok->MustBreakBefore = true;
2518  MustBreakBeforeNextToken = false;
2519  }
2520 }
2521 
2522 } // end namespace format
2523 } // end namespace clang
static bool isJSDeclOrStmt(const AdditionalKeywords &Keywords, const FormatToken *FormatTok)
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
SmallVector< UnwrappedLine, 0 > Children
static bool continuesLineCommentSection(const FormatToken &FormatTok, const UnwrappedLine &Line, llvm::Regex &CommentPragmasRegex)
UnwrappedLineParser(const FormatStyle &Style, const AdditionalKeywords &Keywords, unsigned FirstStartColumn, ArrayRef< FormatToken *> Tokens, UnwrappedLineConsumer &Callback)
bool AfterUnion
Wrap union definitions.
Definition: Format.h:683
Indent in all namespaces.
Definition: Format.h:1296
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
Definition: opencl-c.h:60
static bool isIIFE(const UnwrappedLine &Line, const AdditionalKeywords &Keywords)
Token Tok
The Token.
Definition: FormatToken.h:124
Should be used for Protocol Buffers (https://developers.google.com/protocol-buffers/).
Definition: Format.h:1209
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {...
Definition: Token.h:95
bool IndentCaseLabels
Indent case labels one level from the switch statement.
Definition: Format.h:1088
unsigned OriginalColumn
The original 0-based column of this token, including expanded tabs.
Definition: FormatToken.h:215
static LLVM_ATTRIBUTE_UNUSED void printDebugInfo(const UnwrappedLine &Line, StringRef Prefix="")
StringRef P
Parser - This implements a parser for the C family of languages.
Definition: Parser.h:57
static bool mustBeJSIdent(const AdditionalKeywords &Keywords, const FormatToken *FormatTok)
bool AfterExternBlock
Wrap extern blocks.
Definition: Format.h:697
bool IsFirst
Indicates that this is the first token of the file.
Definition: FormatToken.h:156
Does not indent any directives.
Definition: Format.h:1100
bool isAnyIdentifier() const
Return true if this is a raw identifier (when lexing in raw mode) or a non-keyword identifier (when l...
Definition: Token.h:107
bool isBinaryOperator() const
Definition: FormatToken.h:389
PPDirectiveIndentStyle IndentPPDirectives
The preprocessor directive indenting style to use.
Definition: Format.h:1113
virtual void consumeUnwrappedLine(const UnwrappedLine &Line)=0
unsigned NewlinesBefore
The number of newlines immediately before the Token.
Definition: FormatToken.h:130
tok::TokenKind getKind() const
Definition: Token.h:90
bool isLiteral() const
Return true if this is a "literal", like a numeric constant, string, etc.
Definition: Token.h:113
unsigned Level
The indent level of the UnwrappedLine.
bool closesScope() const
Returns whether Tok is )]} or a template closing >.
Definition: FormatToken.h:359
bool AfterObjCDeclaration
Wrap ObjC definitions (@autoreleasepool, interfaces, ..).
Definition: Format.h:655
bool IndentBraces
Indent the wrapped braces themselves.
Definition: Format.h:729
Should be used for Java.
Definition: Format.h:1202
FormatToken * Previous
The previous token in the unwrapped line.
Definition: FormatToken.h:280
static bool tokenCanStartNewLine(const clang::Token &Tok)
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
void setKind(tok::TokenKind K)
Definition: Token.h:91
bool isObjCAtKeyword(tok::ObjCKeywordKind objcKey) const
Return true if we have an ObjC keyword identifier.
Definition: Lexer.cpp:57
bool isNot(T Kind) const
Definition: FormatToken.h:313
static void hash_combine(std::size_t &seed, const T &v)
NamespaceIndentationKind NamespaceIndentation
The indentation used for namespaces.
Definition: Format.h:1300
const FormatToken & Tok
static bool isGoogScope(const UnwrappedLine &Line)
bool isCppStructuredBinding(const FormatStyle &Style) const
Returns whether the token is the left square bracket of a C++ structured binding declaration.
Definition: FormatToken.h:478
virtual FormatToken * getNextToken()=0
An unwrapped line is a sequence of Token, that we would like to put on a single line if there was no ...
CompoundStatementIndenter(UnwrappedLineParser *Parser, const FormatStyle &Style, unsigned &LineLevel)
bool isOneOf(A K1, B K2) const
Definition: FormatToken.h:306
ScopedLineState(UnwrappedLineParser &Parser, bool SwitchToPreprocessorLines=false)
std::list< UnwrappedLineNode > Tokens
The Tokens comprising this UnwrappedLine.
Should be used for JavaScript.
Definition: Format.h:1204
ContinuationIndenter * Indenter
const AnnotatedLine * Line
const FunctionProtoType * T
StateNode * Previous
static const size_t kInvalidIndex
bool InPPDirective
Whether this UnwrappedLine is part of a preprocessor directive.
BraceWrappingFlags BraceWrapping
Control of individual brace wrapping cases.
Definition: Format.h:778
bool AfterFunction
Wrap function definitions.
Definition: Format.h:637
A wrapper around a Token storing information about the whitespace characters preceding it...
Definition: FormatToken.h:120
SourceLocation getEnd() const
do v
Definition: arm_acle.h:78
#define false
Definition: stdbool.h:33
bool is(tok::TokenKind Kind) const
Definition: FormatToken.h:297
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:177
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
This file contains the declaration of the UnwrappedLineParser, which turns a stream of tokens into Un...
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
StringRef TokenText
The raw text of the token.
Definition: FormatToken.h:168
static bool mustBeJSIdentOrValue(const AdditionalKeywords &Keywords, const FormatToken *FormatTok)
virtual FormatToken * setPosition(unsigned Position)=0
tok::ObjCKeywordKind getObjCKeywordID() const
Return the ObjC keyword kind.
Definition: Lexer.cpp:66
bool isSimpleTypeSpecifier() const
Determine whether the token is a simple-type-specifier.
Definition: FormatToken.cpp:40
The FormatStyle is used to configure the formatting to follow specific guidelines.
Definition: Format.h:46
static bool ShouldBreakBeforeBrace(const FormatStyle &Style, const FormatToken &InitialToken)
Indent only in inner namespaces (nested in other namespaces).
Definition: Format.h:1286
LanguageKind Language
Language, this format style is targeted at.
Definition: Format.h:1219
ast_type_traits::DynTypedNode Node
bool isNot(tok::TokenKind K) const
Definition: Token.h:96
Dataflow Directional Tag Classes.
bool Finalized
If true, this token has been fully formatted (indented and potentially re-formatted inside)...
Definition: FormatToken.h:295
Should be used for TableGen code.
Definition: Format.h:1211
tok::PPKeywordKind getPPKeywordID() const
Return the preprocessor keyword ID for this identifier.
bool AfterStruct
Wrap struct definitions.
Definition: Format.h:669
virtual unsigned getPosition()=0
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:318
bool AfterControlStatement
Wrap control statements (if/for/while/switch/..).
Definition: Format.h:609
Indents directives after the hash.
Definition: Format.h:1109
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:61
Represents a complete lambda introducer.
Definition: DeclSpec.h:2508
bool MustBreakBefore
Whether there must be a line break before this token.
Definition: FormatToken.h:162
bool AfterClass
Wrap class definitions.
Definition: Format.h:591
Should be used for Protocol Buffer messages in text format (https://developers.google.com/protocol-buffers/).
Definition: Format.h:1214
StringRef Text
Definition: Format.cpp:1346
bool ContinuesLineCommentSection
Does this line comment continue a line comment section?
Definition: FormatToken.h:274
bool isStringLiteral() const
Definition: FormatToken.h:329
SourceLocation getBegin() const
bool AfterNamespace
Wrap namespace definitions.
Definition: Format.h:653
bool HasUnescapedNewline
Whether there is at least one unescaped newline before the Token.
Definition: FormatToken.h:134
BraceBlockKind BlockKind
Contains the kind of block if this token is a brace.
Definition: FormatToken.h:174
void startToken()
Reset all flags to cleared.
Definition: Token.h:169
const FormatStyle & Style