clang  3.8.0
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 #define DEBUG_TYPE "format-parser"
22 
23 namespace clang {
24 namespace format {
25 
27 public:
28  virtual ~FormatTokenSource() {}
29  virtual FormatToken *getNextToken() = 0;
30 
31  virtual unsigned getPosition() = 0;
32  virtual FormatToken *setPosition(unsigned Position) = 0;
33 };
34 
35 namespace {
36 
37 class ScopedDeclarationState {
38 public:
39  ScopedDeclarationState(UnwrappedLine &Line, std::vector<bool> &Stack,
40  bool MustBeDeclaration)
41  : Line(Line), Stack(Stack) {
42  Line.MustBeDeclaration = MustBeDeclaration;
43  Stack.push_back(MustBeDeclaration);
44  }
45  ~ScopedDeclarationState() {
46  Stack.pop_back();
47  if (!Stack.empty())
48  Line.MustBeDeclaration = Stack.back();
49  else
50  Line.MustBeDeclaration = true;
51  }
52 
53 private:
54  UnwrappedLine &Line;
55  std::vector<bool> &Stack;
56 };
57 
58 class ScopedMacroState : public FormatTokenSource {
59 public:
60  ScopedMacroState(UnwrappedLine &Line, FormatTokenSource *&TokenSource,
61  FormatToken *&ResetToken)
62  : Line(Line), TokenSource(TokenSource), ResetToken(ResetToken),
63  PreviousLineLevel(Line.Level), PreviousTokenSource(TokenSource),
64  Token(nullptr) {
65  TokenSource = this;
66  Line.Level = 0;
67  Line.InPPDirective = true;
68  }
69 
70  ~ScopedMacroState() override {
71  TokenSource = PreviousTokenSource;
72  ResetToken = Token;
73  Line.InPPDirective = false;
74  Line.Level = PreviousLineLevel;
75  }
76 
77  FormatToken *getNextToken() override {
78  // The \c UnwrappedLineParser guards against this by never calling
79  // \c getNextToken() after it has encountered the first eof token.
80  assert(!eof());
81  Token = PreviousTokenSource->getNextToken();
82  if (eof())
83  return getFakeEOF();
84  return Token;
85  }
86 
87  unsigned getPosition() override { return PreviousTokenSource->getPosition(); }
88 
89  FormatToken *setPosition(unsigned Position) override {
90  Token = PreviousTokenSource->setPosition(Position);
91  return Token;
92  }
93 
94 private:
95  bool eof() { return Token && Token->HasUnescapedNewline; }
96 
97  FormatToken *getFakeEOF() {
98  static bool EOFInitialized = false;
99  static FormatToken FormatTok;
100  if (!EOFInitialized) {
101  FormatTok.Tok.startToken();
102  FormatTok.Tok.setKind(tok::eof);
103  EOFInitialized = true;
104  }
105  return &FormatTok;
106  }
107 
108  UnwrappedLine &Line;
109  FormatTokenSource *&TokenSource;
110  FormatToken *&ResetToken;
112  FormatTokenSource *PreviousTokenSource;
113 
114  FormatToken *Token;
115 };
116 
117 } // end anonymous namespace
118 
120 public:
122  bool SwitchToPreprocessorLines = false)
123  : Parser(Parser), OriginalLines(Parser.CurrentLines) {
124  if (SwitchToPreprocessorLines)
125  Parser.CurrentLines = &Parser.PreprocessorDirectives;
126  else if (!Parser.Line->Tokens.empty())
127  Parser.CurrentLines = &Parser.Line->Tokens.back().Children;
128  PreBlockLine = std::move(Parser.Line);
129  Parser.Line = llvm::make_unique<UnwrappedLine>();
130  Parser.Line->Level = PreBlockLine->Level;
131  Parser.Line->InPPDirective = PreBlockLine->InPPDirective;
132  }
133 
135  if (!Parser.Line->Tokens.empty()) {
136  Parser.addUnwrappedLine();
137  }
138  assert(Parser.Line->Tokens.empty());
139  Parser.Line = std::move(PreBlockLine);
140  if (Parser.CurrentLines == &Parser.PreprocessorDirectives)
141  Parser.MustBreakBeforeNextToken = true;
142  Parser.CurrentLines = OriginalLines;
143  }
144 
145 private:
147 
148  std::unique_ptr<UnwrappedLine> PreBlockLine;
149  SmallVectorImpl<UnwrappedLine> *OriginalLines;
150 };
151 
153 public:
155  const FormatStyle &Style, unsigned &LineLevel)
156  : LineLevel(LineLevel), OldLineLevel(LineLevel) {
158  Parser->addUnwrappedLine();
159  if (Style.BraceWrapping.IndentBraces)
160  ++LineLevel;
161  }
162  ~CompoundStatementIndenter() { LineLevel = OldLineLevel; }
163 
164 private:
165  unsigned &LineLevel;
166  unsigned OldLineLevel;
167 };
168 
169 namespace {
170 
171 class IndexedTokenSource : public FormatTokenSource {
172 public:
173  IndexedTokenSource(ArrayRef<FormatToken *> Tokens)
174  : Tokens(Tokens), Position(-1) {}
175 
176  FormatToken *getNextToken() override {
177  ++Position;
178  return Tokens[Position];
179  }
180 
181  unsigned getPosition() override {
182  assert(Position >= 0);
183  return Position;
184  }
185 
186  FormatToken *setPosition(unsigned P) override {
187  Position = P;
188  return Tokens[Position];
189  }
190 
191  void reset() { Position = -1; }
192 
193 private:
194  ArrayRef<FormatToken *> Tokens;
195  int Position;
196 };
197 
198 } // end anonymous namespace
199 
204  : Line(new UnwrappedLine), MustBreakBeforeNextToken(false),
205  CurrentLines(&Lines), Style(Style), Keywords(Keywords), Tokens(nullptr),
206  Callback(Callback), AllTokens(Tokens), PPBranchLevel(-1) {}
207 
208 void UnwrappedLineParser::reset() {
209  PPBranchLevel = -1;
210  Line.reset(new UnwrappedLine);
211  CommentsBeforeNextToken.clear();
212  FormatTok = nullptr;
213  MustBreakBeforeNextToken = false;
214  PreprocessorDirectives.clear();
215  CurrentLines = &Lines;
216  DeclarationScopeStack.clear();
217  PPStack.clear();
218 }
219 
221  IndexedTokenSource TokenSource(AllTokens);
222  do {
223  DEBUG(llvm::dbgs() << "----\n");
224  reset();
225  Tokens = &TokenSource;
226  TokenSource.reset();
227 
228  readToken();
229  parseFile();
230  // Create line with eof token.
231  pushToken(FormatTok);
232  addUnwrappedLine();
233 
234  for (SmallVectorImpl<UnwrappedLine>::iterator I = Lines.begin(),
235  E = Lines.end();
236  I != E; ++I) {
237  Callback.consumeUnwrappedLine(*I);
238  }
239  Callback.finishRun();
240  Lines.clear();
241  while (!PPLevelBranchIndex.empty() &&
242  PPLevelBranchIndex.back() + 1 >= PPLevelBranchCount.back()) {
243  PPLevelBranchIndex.resize(PPLevelBranchIndex.size() - 1);
244  PPLevelBranchCount.resize(PPLevelBranchCount.size() - 1);
245  }
246  if (!PPLevelBranchIndex.empty()) {
247  ++PPLevelBranchIndex.back();
248  assert(PPLevelBranchIndex.size() == PPLevelBranchCount.size());
249  assert(PPLevelBranchIndex.back() <= PPLevelBranchCount.back());
250  }
251  } while (!PPLevelBranchIndex.empty());
252 }
253 
254 void UnwrappedLineParser::parseFile() {
255  // The top-level context in a file always has declarations, except for pre-
256  // processor directives and JavaScript files.
257  bool MustBeDeclaration =
258  !Line->InPPDirective && Style.Language != FormatStyle::LK_JavaScript;
259  ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
260  MustBeDeclaration);
261  parseLevel(/*HasOpeningBrace=*/false);
262  // Make sure to format the remaining tokens.
263  flushComments(true);
264  addUnwrappedLine();
265 }
266 
267 void UnwrappedLineParser::parseLevel(bool HasOpeningBrace) {
268  bool SwitchLabelEncountered = false;
269  do {
270  tok::TokenKind kind = FormatTok->Tok.getKind();
271  if (FormatTok->Type == TT_MacroBlockBegin) {
272  kind = tok::l_brace;
273  } else if (FormatTok->Type == TT_MacroBlockEnd) {
274  kind = tok::r_brace;
275  }
276 
277  switch (kind) {
278  case tok::comment:
279  nextToken();
280  addUnwrappedLine();
281  break;
282  case tok::l_brace:
283  // FIXME: Add parameter whether this can happen - if this happens, we must
284  // be in a non-declaration context.
285  if (!FormatTok->is(TT_MacroBlockBegin) && tryToParseBracedList())
286  continue;
287  parseBlock(/*MustBeDeclaration=*/false);
288  addUnwrappedLine();
289  break;
290  case tok::r_brace:
291  if (HasOpeningBrace)
292  return;
293  nextToken();
294  addUnwrappedLine();
295  break;
296  case tok::kw_default:
297  case tok::kw_case:
298  if (!SwitchLabelEncountered &&
299  (Style.IndentCaseLabels || (Line->InPPDirective && Line->Level == 1)))
300  ++Line->Level;
301  SwitchLabelEncountered = true;
302  parseStructuralElement();
303  break;
304  default:
305  parseStructuralElement();
306  break;
307  }
308  } while (!eof());
309 }
310 
311 void UnwrappedLineParser::calculateBraceTypes(bool ExpectClassBody) {
312  // We'll parse forward through the tokens until we hit
313  // a closing brace or eof - note that getNextToken() will
314  // parse macros, so this will magically work inside macro
315  // definitions, too.
316  unsigned StoredPosition = Tokens->getPosition();
317  FormatToken *Tok = FormatTok;
318  const FormatToken *PrevTok = getPreviousToken();
319  // Keep a stack of positions of lbrace tokens. We will
320  // update information about whether an lbrace starts a
321  // braced init list or a different block during the loop.
322  SmallVector<FormatToken *, 8> LBraceStack;
323  assert(Tok->Tok.is(tok::l_brace));
324  do {
325  // Get next non-comment token.
326  FormatToken *NextTok;
327  unsigned ReadTokens = 0;
328  do {
329  NextTok = Tokens->getNextToken();
330  ++ReadTokens;
331  } while (NextTok->is(tok::comment));
332 
333  switch (Tok->Tok.getKind()) {
334  case tok::l_brace:
335  if (Style.Language == FormatStyle::LK_JavaScript && PrevTok &&
336  PrevTok->is(tok::colon))
337  // In TypeScript's TypeMemberLists, there can be semicolons between the
338  // individual members.
339  Tok->BlockKind = BK_BracedInit;
340  else
341  Tok->BlockKind = BK_Unknown;
342  LBraceStack.push_back(Tok);
343  break;
344  case tok::r_brace:
345  if (LBraceStack.empty())
346  break;
347  if (LBraceStack.back()->BlockKind == BK_Unknown) {
348  bool ProbablyBracedList = false;
349  if (Style.Language == FormatStyle::LK_Proto) {
350  ProbablyBracedList = NextTok->isOneOf(tok::comma, tok::r_square);
351  } else {
352  // Using OriginalColumn to distinguish between ObjC methods and
353  // binary operators is a bit hacky.
354  bool NextIsObjCMethod = NextTok->isOneOf(tok::plus, tok::minus) &&
355  NextTok->OriginalColumn == 0;
356 
357  // If there is a comma, semicolon or right paren after the closing
358  // brace, we assume this is a braced initializer list. Note that
359  // regardless how we mark inner braces here, we will overwrite the
360  // BlockKind later if we parse a braced list (where all blocks
361  // inside are by default braced lists), or when we explicitly detect
362  // blocks (for example while parsing lambdas).
363  //
364  // We exclude + and - as they can be ObjC visibility modifiers.
365  ProbablyBracedList =
366  NextTok->isOneOf(tok::comma, tok::period, tok::colon,
367  tok::r_paren, tok::r_square, tok::l_brace,
368  tok::l_square, tok::l_paren, tok::ellipsis) ||
369  (NextTok->is(tok::semi) &&
370  (!ExpectClassBody || LBraceStack.size() != 1)) ||
371  (NextTok->isBinaryOperator() && !NextIsObjCMethod);
372  }
373  if (ProbablyBracedList) {
374  Tok->BlockKind = BK_BracedInit;
375  LBraceStack.back()->BlockKind = BK_BracedInit;
376  } else {
377  Tok->BlockKind = BK_Block;
378  LBraceStack.back()->BlockKind = BK_Block;
379  }
380  }
381  LBraceStack.pop_back();
382  break;
383  case tok::at:
384  case tok::semi:
385  case tok::kw_if:
386  case tok::kw_while:
387  case tok::kw_for:
388  case tok::kw_switch:
389  case tok::kw_try:
390  case tok::kw___try:
391  if (!LBraceStack.empty() && LBraceStack.back()->BlockKind == BK_Unknown)
392  LBraceStack.back()->BlockKind = BK_Block;
393  break;
394  default:
395  break;
396  }
397  PrevTok = Tok;
398  Tok = NextTok;
399  } while (Tok->Tok.isNot(tok::eof) && !LBraceStack.empty());
400 
401  // Assume other blocks for all unclosed opening braces.
402  for (unsigned i = 0, e = LBraceStack.size(); i != e; ++i) {
403  if (LBraceStack[i]->BlockKind == BK_Unknown)
404  LBraceStack[i]->BlockKind = BK_Block;
405  }
406 
407  FormatTok = Tokens->setPosition(StoredPosition);
408 }
409 
410 void UnwrappedLineParser::parseBlock(bool MustBeDeclaration, bool AddLevel,
411  bool MunchSemi) {
412  assert(FormatTok->isOneOf(tok::l_brace, TT_MacroBlockBegin) &&
413  "'{' or macro block token expected");
414  const bool MacroBlock = FormatTok->is(TT_MacroBlockBegin);
415  FormatTok->BlockKind = BK_Block;
416 
417  unsigned InitialLevel = Line->Level;
418  nextToken();
419 
420  if (MacroBlock && FormatTok->is(tok::l_paren))
421  parseParens();
422 
423  addUnwrappedLine();
424 
425  ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
426  MustBeDeclaration);
427  if (AddLevel)
428  ++Line->Level;
429  parseLevel(/*HasOpeningBrace=*/true);
430 
431  if (MacroBlock ? !FormatTok->is(TT_MacroBlockEnd)
432  : !FormatTok->is(tok::r_brace)) {
433  Line->Level = InitialLevel;
434  FormatTok->BlockKind = BK_Block;
435  return;
436  }
437 
438  nextToken(); // Munch the closing brace.
439 
440  if (MacroBlock && FormatTok->is(tok::l_paren))
441  parseParens();
442 
443  if (MunchSemi && FormatTok->Tok.is(tok::semi))
444  nextToken();
445  Line->Level = InitialLevel;
446 }
447 
448 static bool isGoogScope(const UnwrappedLine &Line) {
449  // FIXME: Closure-library specific stuff should not be hard-coded but be
450  // configurable.
451  if (Line.Tokens.size() < 4)
452  return false;
453  auto I = Line.Tokens.begin();
454  if (I->Tok->TokenText != "goog")
455  return false;
456  ++I;
457  if (I->Tok->isNot(tok::period))
458  return false;
459  ++I;
460  if (I->Tok->TokenText != "scope")
461  return false;
462  ++I;
463  return I->Tok->is(tok::l_paren);
464 }
465 
467  const FormatToken &InitialToken) {
468  if (InitialToken.is(tok::kw_namespace))
469  return Style.BraceWrapping.AfterNamespace;
470  if (InitialToken.is(tok::kw_class))
471  return Style.BraceWrapping.AfterClass;
472  if (InitialToken.is(tok::kw_union))
473  return Style.BraceWrapping.AfterUnion;
474  if (InitialToken.is(tok::kw_struct))
475  return Style.BraceWrapping.AfterStruct;
476  return false;
477 }
478 
479 void UnwrappedLineParser::parseChildBlock() {
480  FormatTok->BlockKind = BK_Block;
481  nextToken();
482  {
483  bool GoogScope =
485  ScopedLineState LineState(*this);
486  ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
487  /*MustBeDeclaration=*/false);
488  Line->Level += GoogScope ? 0 : 1;
489  parseLevel(/*HasOpeningBrace=*/true);
490  flushComments(isOnNewLine(*FormatTok));
491  Line->Level -= GoogScope ? 0 : 1;
492  }
493  nextToken();
494 }
495 
496 void UnwrappedLineParser::parsePPDirective() {
497  assert(FormatTok->Tok.is(tok::hash) && "'#' expected");
498  ScopedMacroState MacroState(*Line, Tokens, FormatTok);
499  nextToken();
500 
501  if (!FormatTok->Tok.getIdentifierInfo()) {
502  parsePPUnknown();
503  return;
504  }
505 
506  switch (FormatTok->Tok.getIdentifierInfo()->getPPKeywordID()) {
507  case tok::pp_define:
508  parsePPDefine();
509  return;
510  case tok::pp_if:
511  parsePPIf(/*IfDef=*/false);
512  break;
513  case tok::pp_ifdef:
514  case tok::pp_ifndef:
515  parsePPIf(/*IfDef=*/true);
516  break;
517  case tok::pp_else:
518  parsePPElse();
519  break;
520  case tok::pp_elif:
521  parsePPElIf();
522  break;
523  case tok::pp_endif:
524  parsePPEndIf();
525  break;
526  default:
527  parsePPUnknown();
528  break;
529  }
530 }
531 
532 void UnwrappedLineParser::conditionalCompilationCondition(bool Unreachable) {
533  if (Unreachable || (!PPStack.empty() && PPStack.back() == PP_Unreachable))
534  PPStack.push_back(PP_Unreachable);
535  else
536  PPStack.push_back(PP_Conditional);
537 }
538 
539 void UnwrappedLineParser::conditionalCompilationStart(bool Unreachable) {
540  ++PPBranchLevel;
541  assert(PPBranchLevel >= 0 && PPBranchLevel <= (int)PPLevelBranchIndex.size());
542  if (PPBranchLevel == (int)PPLevelBranchIndex.size()) {
543  PPLevelBranchIndex.push_back(0);
544  PPLevelBranchCount.push_back(0);
545  }
546  PPChainBranchIndex.push(0);
547  bool Skip = PPLevelBranchIndex[PPBranchLevel] > 0;
548  conditionalCompilationCondition(Unreachable || Skip);
549 }
550 
551 void UnwrappedLineParser::conditionalCompilationAlternative() {
552  if (!PPStack.empty())
553  PPStack.pop_back();
554  assert(PPBranchLevel < (int)PPLevelBranchIndex.size());
555  if (!PPChainBranchIndex.empty())
556  ++PPChainBranchIndex.top();
557  conditionalCompilationCondition(
558  PPBranchLevel >= 0 && !PPChainBranchIndex.empty() &&
559  PPLevelBranchIndex[PPBranchLevel] != PPChainBranchIndex.top());
560 }
561 
562 void UnwrappedLineParser::conditionalCompilationEnd() {
563  assert(PPBranchLevel < (int)PPLevelBranchIndex.size());
564  if (PPBranchLevel >= 0 && !PPChainBranchIndex.empty()) {
565  if (PPChainBranchIndex.top() + 1 > PPLevelBranchCount[PPBranchLevel]) {
566  PPLevelBranchCount[PPBranchLevel] = PPChainBranchIndex.top() + 1;
567  }
568  }
569  // Guard against #endif's without #if.
570  if (PPBranchLevel > 0)
571  --PPBranchLevel;
572  if (!PPChainBranchIndex.empty())
573  PPChainBranchIndex.pop();
574  if (!PPStack.empty())
575  PPStack.pop_back();
576 }
577 
578 void UnwrappedLineParser::parsePPIf(bool IfDef) {
579  nextToken();
580  bool IsLiteralFalse = (FormatTok->Tok.isLiteral() &&
581  FormatTok->Tok.getLiteralData() != nullptr &&
582  StringRef(FormatTok->Tok.getLiteralData(),
583  FormatTok->Tok.getLength()) == "0") ||
584  FormatTok->Tok.is(tok::kw_false);
585  conditionalCompilationStart(!IfDef && IsLiteralFalse);
586  parsePPUnknown();
587 }
588 
589 void UnwrappedLineParser::parsePPElse() {
590  conditionalCompilationAlternative();
591  parsePPUnknown();
592 }
593 
594 void UnwrappedLineParser::parsePPElIf() { parsePPElse(); }
595 
596 void UnwrappedLineParser::parsePPEndIf() {
597  conditionalCompilationEnd();
598  parsePPUnknown();
599 }
600 
601 void UnwrappedLineParser::parsePPDefine() {
602  nextToken();
603 
604  if (FormatTok->Tok.getKind() != tok::identifier) {
605  parsePPUnknown();
606  return;
607  }
608  nextToken();
609  if (FormatTok->Tok.getKind() == tok::l_paren &&
610  FormatTok->WhitespaceRange.getBegin() ==
611  FormatTok->WhitespaceRange.getEnd()) {
612  parseParens();
613  }
614  addUnwrappedLine();
615  Line->Level = 1;
616 
617  // Errors during a preprocessor directive can only affect the layout of the
618  // preprocessor directive, and thus we ignore them. An alternative approach
619  // would be to use the same approach we use on the file level (no
620  // re-indentation if there was a structural error) within the macro
621  // definition.
622  parseFile();
623 }
624 
625 void UnwrappedLineParser::parsePPUnknown() {
626  do {
627  nextToken();
628  } while (!eof());
629  addUnwrappedLine();
630 }
631 
632 // Here we blacklist certain tokens that are not usually the first token in an
633 // unwrapped line. This is used in attempt to distinguish macro calls without
634 // trailing semicolons from other constructs split to several lines.
635 static bool tokenCanStartNewLine(const clang::Token &Tok) {
636  // Semicolon can be a null-statement, l_square can be a start of a macro or
637  // a C++11 attribute, but this doesn't seem to be common.
638  return Tok.isNot(tok::semi) && Tok.isNot(tok::l_brace) &&
639  Tok.isNot(tok::l_square) &&
640  // Tokens that can only be used as binary operators and a part of
641  // overloaded operator names.
642  Tok.isNot(tok::period) && Tok.isNot(tok::periodstar) &&
643  Tok.isNot(tok::arrow) && Tok.isNot(tok::arrowstar) &&
644  Tok.isNot(tok::less) && Tok.isNot(tok::greater) &&
645  Tok.isNot(tok::slash) && Tok.isNot(tok::percent) &&
646  Tok.isNot(tok::lessless) && Tok.isNot(tok::greatergreater) &&
647  Tok.isNot(tok::equal) && Tok.isNot(tok::plusequal) &&
648  Tok.isNot(tok::minusequal) && Tok.isNot(tok::starequal) &&
649  Tok.isNot(tok::slashequal) && Tok.isNot(tok::percentequal) &&
650  Tok.isNot(tok::ampequal) && Tok.isNot(tok::pipeequal) &&
651  Tok.isNot(tok::caretequal) && Tok.isNot(tok::greatergreaterequal) &&
652  Tok.isNot(tok::lesslessequal) &&
653  // Colon is used in labels, base class lists, initializer lists,
654  // range-based for loops, ternary operator, but should never be the
655  // first token in an unwrapped line.
656  Tok.isNot(tok::colon) &&
657  // 'noexcept' is a trailing annotation.
658  Tok.isNot(tok::kw_noexcept);
659 }
660 
661 void UnwrappedLineParser::parseStructuralElement() {
662  assert(!FormatTok->is(tok::l_brace));
663  if (Style.Language == FormatStyle::LK_TableGen &&
664  FormatTok->is(tok::pp_include)) {
665  nextToken();
666  if (FormatTok->is(tok::string_literal))
667  nextToken();
668  addUnwrappedLine();
669  return;
670  }
671  switch (FormatTok->Tok.getKind()) {
672  case tok::at:
673  nextToken();
674  if (FormatTok->Tok.is(tok::l_brace)) {
675  parseBracedList();
676  break;
677  }
678  switch (FormatTok->Tok.getObjCKeywordID()) {
679  case tok::objc_public:
680  case tok::objc_protected:
681  case tok::objc_package:
682  case tok::objc_private:
683  return parseAccessSpecifier();
684  case tok::objc_interface:
685  case tok::objc_implementation:
686  return parseObjCInterfaceOrImplementation();
687  case tok::objc_protocol:
688  return parseObjCProtocol();
689  case tok::objc_end:
690  return; // Handled by the caller.
691  case tok::objc_optional:
692  case tok::objc_required:
693  nextToken();
694  addUnwrappedLine();
695  return;
696  case tok::objc_autoreleasepool:
697  nextToken();
698  if (FormatTok->Tok.is(tok::l_brace)) {
700  addUnwrappedLine();
701  parseBlock(/*MustBeDeclaration=*/false);
702  }
703  addUnwrappedLine();
704  return;
705  case tok::objc_try:
706  // This branch isn't strictly necessary (the kw_try case below would
707  // do this too after the tok::at is parsed above). But be explicit.
708  parseTryCatch();
709  return;
710  default:
711  break;
712  }
713  break;
714  case tok::kw_asm:
715  nextToken();
716  if (FormatTok->is(tok::l_brace)) {
717  FormatTok->Type = TT_InlineASMBrace;
718  nextToken();
719  while (FormatTok && FormatTok->isNot(tok::eof)) {
720  if (FormatTok->is(tok::r_brace)) {
721  FormatTok->Type = TT_InlineASMBrace;
722  nextToken();
723  addUnwrappedLine();
724  break;
725  }
726  FormatTok->Finalized = true;
727  nextToken();
728  }
729  }
730  break;
731  case tok::kw_namespace:
732  parseNamespace();
733  return;
734  case tok::kw_inline:
735  nextToken();
736  if (FormatTok->Tok.is(tok::kw_namespace)) {
737  parseNamespace();
738  return;
739  }
740  break;
741  case tok::kw_public:
742  case tok::kw_protected:
743  case tok::kw_private:
744  if (Style.Language == FormatStyle::LK_Java ||
746  nextToken();
747  else
748  parseAccessSpecifier();
749  return;
750  case tok::kw_if:
751  parseIfThenElse();
752  return;
753  case tok::kw_for:
754  case tok::kw_while:
755  parseForOrWhileLoop();
756  return;
757  case tok::kw_do:
758  parseDoWhile();
759  return;
760  case tok::kw_switch:
761  parseSwitch();
762  return;
763  case tok::kw_default:
764  nextToken();
765  parseLabel();
766  return;
767  case tok::kw_case:
768  parseCaseLabel();
769  return;
770  case tok::kw_try:
771  case tok::kw___try:
772  parseTryCatch();
773  return;
774  case tok::kw_extern:
775  nextToken();
776  if (FormatTok->Tok.is(tok::string_literal)) {
777  nextToken();
778  if (FormatTok->Tok.is(tok::l_brace)) {
779  parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/false);
780  addUnwrappedLine();
781  return;
782  }
783  }
784  break;
785  case tok::kw_export:
786  if (Style.Language == FormatStyle::LK_JavaScript) {
787  parseJavaScriptEs6ImportExport();
788  return;
789  }
790  break;
791  case tok::identifier:
792  if (FormatTok->is(TT_ForEachMacro)) {
793  parseForOrWhileLoop();
794  return;
795  }
796  if (FormatTok->is(TT_MacroBlockBegin)) {
797  parseBlock(/*MustBeDeclaration=*/false, /*AddLevel=*/true,
798  /*MunchSemi=*/false);
799  return;
800  }
801  if (Style.Language == FormatStyle::LK_JavaScript &&
802  FormatTok->is(Keywords.kw_import)) {
803  parseJavaScriptEs6ImportExport();
804  return;
805  }
806  if (FormatTok->isOneOf(Keywords.kw_signals, Keywords.kw_qsignals,
807  Keywords.kw_slots, Keywords.kw_qslots)) {
808  nextToken();
809  if (FormatTok->is(tok::colon)) {
810  nextToken();
811  addUnwrappedLine();
812  }
813  return;
814  }
815  // In all other cases, parse the declaration.
816  break;
817  default:
818  break;
819  }
820  do {
821  switch (FormatTok->Tok.getKind()) {
822  case tok::at:
823  nextToken();
824  if (FormatTok->Tok.is(tok::l_brace))
825  parseBracedList();
826  break;
827  case tok::kw_enum:
828  // parseEnum falls through and does not yet add an unwrapped line as an
829  // enum definition can start a structural element.
830  if (!parseEnum())
831  break;
832  // This only applies for C++.
833  if (Style.Language != FormatStyle::LK_Cpp) {
834  addUnwrappedLine();
835  return;
836  }
837  break;
838  case tok::kw_typedef:
839  nextToken();
840  if (FormatTok->isOneOf(Keywords.kw_NS_ENUM, Keywords.kw_NS_OPTIONS,
841  Keywords.kw_CF_ENUM, Keywords.kw_CF_OPTIONS))
842  parseEnum();
843  break;
844  case tok::kw_struct:
845  case tok::kw_union:
846  case tok::kw_class:
847  // parseRecord falls through and does not yet add an unwrapped line as a
848  // record declaration or definition can start a structural element.
849  parseRecord();
850  // This does not apply for Java and JavaScript.
851  if (Style.Language == FormatStyle::LK_Java ||
853  if (FormatTok->is(tok::semi))
854  nextToken();
855  addUnwrappedLine();
856  return;
857  }
858  break;
859  case tok::period:
860  nextToken();
861  // In Java, classes have an implicit static member "class".
862  if (Style.Language == FormatStyle::LK_Java && FormatTok &&
863  FormatTok->is(tok::kw_class))
864  nextToken();
865  if (Style.Language == FormatStyle::LK_JavaScript && FormatTok &&
866  FormatTok->Tok.getIdentifierInfo())
867  // JavaScript only has pseudo keywords, all keywords are allowed to
868  // appear in "IdentifierName" positions. See http://es5.github.io/#x7.6
869  nextToken();
870  break;
871  case tok::semi:
872  nextToken();
873  addUnwrappedLine();
874  return;
875  case tok::r_brace:
876  addUnwrappedLine();
877  return;
878  case tok::l_paren:
879  parseParens();
880  break;
881  case tok::kw_operator:
882  nextToken();
883  if (FormatTok->isBinaryOperator())
884  nextToken();
885  break;
886  case tok::caret:
887  nextToken();
888  if (FormatTok->Tok.isAnyIdentifier() ||
889  FormatTok->isSimpleTypeSpecifier())
890  nextToken();
891  if (FormatTok->is(tok::l_paren))
892  parseParens();
893  if (FormatTok->is(tok::l_brace))
894  parseChildBlock();
895  break;
896  case tok::l_brace:
897  if (!tryToParseBracedList()) {
898  // A block outside of parentheses must be the last part of a
899  // structural element.
900  // FIXME: Figure out cases where this is not true, and add projections
901  // for them (the one we know is missing are lambdas).
902  if (Style.BraceWrapping.AfterFunction)
903  addUnwrappedLine();
904  FormatTok->Type = TT_FunctionLBrace;
905  parseBlock(/*MustBeDeclaration=*/false);
906  addUnwrappedLine();
907  return;
908  }
909  // Otherwise this was a braced init list, and the structural
910  // element continues.
911  break;
912  case tok::kw_try:
913  // We arrive here when parsing function-try blocks.
914  parseTryCatch();
915  return;
916  case tok::identifier: {
917  if (FormatTok->is(TT_MacroBlockEnd)) {
918  addUnwrappedLine();
919  return;
920  }
921 
922  // Parse function literal unless 'function' is the first token in a line
923  // in which case this should be treated as a free-standing function.
924  if (Style.Language == FormatStyle::LK_JavaScript &&
925  FormatTok->is(Keywords.kw_function) && Line->Tokens.size() > 0) {
926  tryToParseJSFunction();
927  break;
928  }
929  if ((Style.Language == FormatStyle::LK_JavaScript ||
930  Style.Language == FormatStyle::LK_Java) &&
931  FormatTok->is(Keywords.kw_interface)) {
932  parseRecord();
933  addUnwrappedLine();
934  return;
935  }
936 
937  StringRef Text = FormatTok->TokenText;
938  nextToken();
939  if (Line->Tokens.size() == 1 &&
940  // JS doesn't have macros, and within classes colons indicate fields,
941  // not labels.
943  if (FormatTok->Tok.is(tok::colon) && !Line->MustBeDeclaration) {
944  parseLabel();
945  return;
946  }
947  // Recognize function-like macro usages without trailing semicolon as
948  // well as free-standing macros like Q_OBJECT.
949  bool FunctionLike = FormatTok->is(tok::l_paren);
950  if (FunctionLike)
951  parseParens();
952 
953  bool FollowedByNewline =
954  CommentsBeforeNextToken.empty()
955  ? FormatTok->NewlinesBefore > 0
956  : CommentsBeforeNextToken.front()->NewlinesBefore > 0;
957 
958  if (FollowedByNewline && (Text.size() >= 5 || FunctionLike) &&
959  tokenCanStartNewLine(FormatTok->Tok) && Text == Text.upper()) {
960  addUnwrappedLine();
961  return;
962  }
963  }
964  break;
965  }
966  case tok::equal:
967  // Fat arrows (=>) have tok::TokenKind tok::equal but TokenType
968  // TT_JsFatArrow. The always start an expression or a child block if
969  // followed by a curly.
970  if (FormatTok->is(TT_JsFatArrow)) {
971  nextToken();
972  if (FormatTok->is(tok::l_brace))
973  parseChildBlock();
974  break;
975  }
976 
977  nextToken();
978  if (FormatTok->Tok.is(tok::l_brace)) {
979  parseBracedList();
980  }
981  break;
982  case tok::l_square:
983  parseSquare();
984  break;
985  case tok::kw_new:
986  parseNew();
987  break;
988  default:
989  nextToken();
990  break;
991  }
992  } while (!eof());
993 }
994 
995 bool UnwrappedLineParser::tryToParseLambda() {
996  if (Style.Language != FormatStyle::LK_Cpp) {
997  nextToken();
998  return false;
999  }
1000  const FormatToken* Previous = getPreviousToken();
1001  if (Previous &&
1002  (Previous->isOneOf(tok::identifier, tok::kw_operator, tok::kw_new,
1003  tok::kw_delete) ||
1004  Previous->closesScope() || Previous->isSimpleTypeSpecifier())) {
1005  nextToken();
1006  return false;
1007  }
1008  assert(FormatTok->is(tok::l_square));
1009  FormatToken &LSquare = *FormatTok;
1010  if (!tryToParseLambdaIntroducer())
1011  return false;
1012 
1013  while (FormatTok->isNot(tok::l_brace)) {
1014  if (FormatTok->isSimpleTypeSpecifier()) {
1015  nextToken();
1016  continue;
1017  }
1018  switch (FormatTok->Tok.getKind()) {
1019  case tok::l_brace:
1020  break;
1021  case tok::l_paren:
1022  parseParens();
1023  break;
1024  case tok::amp:
1025  case tok::star:
1026  case tok::kw_const:
1027  case tok::comma:
1028  case tok::less:
1029  case tok::greater:
1030  case tok::identifier:
1031  case tok::numeric_constant:
1032  case tok::coloncolon:
1033  case tok::kw_mutable:
1034  nextToken();
1035  break;
1036  case tok::arrow:
1037  FormatTok->Type = TT_LambdaArrow;
1038  nextToken();
1039  break;
1040  default:
1041  return true;
1042  }
1043  }
1044  LSquare.Type = TT_LambdaLSquare;
1045  parseChildBlock();
1046  return true;
1047 }
1048 
1049 bool UnwrappedLineParser::tryToParseLambdaIntroducer() {
1050  nextToken();
1051  if (FormatTok->is(tok::equal)) {
1052  nextToken();
1053  if (FormatTok->is(tok::r_square)) {
1054  nextToken();
1055  return true;
1056  }
1057  if (FormatTok->isNot(tok::comma))
1058  return false;
1059  nextToken();
1060  } else if (FormatTok->is(tok::amp)) {
1061  nextToken();
1062  if (FormatTok->is(tok::r_square)) {
1063  nextToken();
1064  return true;
1065  }
1066  if (!FormatTok->isOneOf(tok::comma, tok::identifier)) {
1067  return false;
1068  }
1069  if (FormatTok->is(tok::comma))
1070  nextToken();
1071  } else if (FormatTok->is(tok::r_square)) {
1072  nextToken();
1073  return true;
1074  }
1075  do {
1076  if (FormatTok->is(tok::amp))
1077  nextToken();
1078  if (!FormatTok->isOneOf(tok::identifier, tok::kw_this))
1079  return false;
1080  nextToken();
1081  if (FormatTok->is(tok::ellipsis))
1082  nextToken();
1083  if (FormatTok->is(tok::comma)) {
1084  nextToken();
1085  } else if (FormatTok->is(tok::r_square)) {
1086  nextToken();
1087  return true;
1088  } else {
1089  return false;
1090  }
1091  } while (!eof());
1092  return false;
1093 }
1094 
1095 void UnwrappedLineParser::tryToParseJSFunction() {
1096  nextToken();
1097 
1098  // Consume function name.
1099  if (FormatTok->is(tok::identifier))
1100  nextToken();
1101 
1102  if (FormatTok->isNot(tok::l_paren))
1103  return;
1104 
1105  // Parse formal parameter list.
1106  parseParens();
1107 
1108  if (FormatTok->is(tok::colon)) {
1109  // Parse a type definition.
1110  nextToken();
1111 
1112  // Eat the type declaration. For braced inline object types, balance braces,
1113  // otherwise just parse until finding an l_brace for the function body.
1114  if (FormatTok->is(tok::l_brace))
1115  tryToParseBracedList();
1116  else
1117  while (FormatTok->isNot(tok::l_brace) && !eof())
1118  nextToken();
1119  }
1120 
1121  parseChildBlock();
1122 }
1123 
1124 bool UnwrappedLineParser::tryToParseBracedList() {
1125  if (FormatTok->BlockKind == BK_Unknown)
1126  calculateBraceTypes();
1127  assert(FormatTok->BlockKind != BK_Unknown);
1128  if (FormatTok->BlockKind == BK_Block)
1129  return false;
1130  parseBracedList();
1131  return true;
1132 }
1133 
1134 bool UnwrappedLineParser::parseBracedList(bool ContinueOnSemicolons) {
1135  bool HasError = false;
1136  nextToken();
1137 
1138  // FIXME: Once we have an expression parser in the UnwrappedLineParser,
1139  // replace this by using parseAssigmentExpression() inside.
1140  do {
1141  if (Style.Language == FormatStyle::LK_JavaScript) {
1142  if (FormatTok->is(Keywords.kw_function)) {
1143  tryToParseJSFunction();
1144  continue;
1145  }
1146  if (FormatTok->is(TT_JsFatArrow)) {
1147  nextToken();
1148  // Fat arrows can be followed by simple expressions or by child blocks
1149  // in curly braces.
1150  if (FormatTok->is(tok::l_brace)) {
1151  parseChildBlock();
1152  continue;
1153  }
1154  }
1155  }
1156  switch (FormatTok->Tok.getKind()) {
1157  case tok::caret:
1158  nextToken();
1159  if (FormatTok->is(tok::l_brace)) {
1160  parseChildBlock();
1161  }
1162  break;
1163  case tok::l_square:
1164  tryToParseLambda();
1165  break;
1166  case tok::l_brace:
1167  // Assume there are no blocks inside a braced init list apart
1168  // from the ones we explicitly parse out (like lambdas).
1169  FormatTok->BlockKind = BK_BracedInit;
1170  parseBracedList();
1171  break;
1172  case tok::l_paren:
1173  parseParens();
1174  // JavaScript can just have free standing methods and getters/setters in
1175  // object literals. Detect them by a "{" following ")".
1176  if (Style.Language == FormatStyle::LK_JavaScript) {
1177  if (FormatTok->is(tok::l_brace))
1178  parseChildBlock();
1179  break;
1180  }
1181  break;
1182  case tok::r_brace:
1183  nextToken();
1184  return !HasError;
1185  case tok::semi:
1186  // JavaScript (or more precisely TypeScript) can have semicolons in braced
1187  // lists (in so-called TypeMemberLists). Thus, the semicolon cannot be
1188  // used for error recovery if we have otherwise determined that this is
1189  // a braced list.
1190  if (Style.Language == FormatStyle::LK_JavaScript) {
1191  nextToken();
1192  break;
1193  }
1194  HasError = true;
1195  if (!ContinueOnSemicolons)
1196  return !HasError;
1197  nextToken();
1198  break;
1199  case tok::comma:
1200  nextToken();
1201  break;
1202  default:
1203  nextToken();
1204  break;
1205  }
1206  } while (!eof());
1207  return false;
1208 }
1209 
1210 void UnwrappedLineParser::parseParens() {
1211  assert(FormatTok->Tok.is(tok::l_paren) && "'(' expected.");
1212  nextToken();
1213  do {
1214  switch (FormatTok->Tok.getKind()) {
1215  case tok::l_paren:
1216  parseParens();
1217  if (Style.Language == FormatStyle::LK_Java && FormatTok->is(tok::l_brace))
1218  parseChildBlock();
1219  break;
1220  case tok::r_paren:
1221  nextToken();
1222  return;
1223  case tok::r_brace:
1224  // A "}" inside parenthesis is an error if there wasn't a matching "{".
1225  return;
1226  case tok::l_square:
1227  tryToParseLambda();
1228  break;
1229  case tok::l_brace:
1230  if (!tryToParseBracedList())
1231  parseChildBlock();
1232  break;
1233  case tok::at:
1234  nextToken();
1235  if (FormatTok->Tok.is(tok::l_brace))
1236  parseBracedList();
1237  break;
1238  case tok::identifier:
1239  if (Style.Language == FormatStyle::LK_JavaScript &&
1240  FormatTok->is(Keywords.kw_function))
1241  tryToParseJSFunction();
1242  else
1243  nextToken();
1244  break;
1245  default:
1246  nextToken();
1247  break;
1248  }
1249  } while (!eof());
1250 }
1251 
1252 void UnwrappedLineParser::parseSquare() {
1253  assert(FormatTok->Tok.is(tok::l_square) && "'[' expected.");
1254  if (tryToParseLambda())
1255  return;
1256  do {
1257  switch (FormatTok->Tok.getKind()) {
1258  case tok::l_paren:
1259  parseParens();
1260  break;
1261  case tok::r_square:
1262  nextToken();
1263  return;
1264  case tok::r_brace:
1265  // A "}" inside parenthesis is an error if there wasn't a matching "{".
1266  return;
1267  case tok::l_square:
1268  parseSquare();
1269  break;
1270  case tok::l_brace: {
1271  if (!tryToParseBracedList())
1272  parseChildBlock();
1273  break;
1274  }
1275  case tok::at:
1276  nextToken();
1277  if (FormatTok->Tok.is(tok::l_brace))
1278  parseBracedList();
1279  break;
1280  default:
1281  nextToken();
1282  break;
1283  }
1284  } while (!eof());
1285 }
1286 
1287 void UnwrappedLineParser::parseIfThenElse() {
1288  assert(FormatTok->Tok.is(tok::kw_if) && "'if' expected");
1289  nextToken();
1290  if (FormatTok->Tok.is(tok::l_paren))
1291  parseParens();
1292  bool NeedsUnwrappedLine = false;
1293  if (FormatTok->Tok.is(tok::l_brace)) {
1294  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1295  parseBlock(/*MustBeDeclaration=*/false);
1296  if (Style.BraceWrapping.BeforeElse)
1297  addUnwrappedLine();
1298  else
1299  NeedsUnwrappedLine = true;
1300  } else {
1301  addUnwrappedLine();
1302  ++Line->Level;
1303  parseStructuralElement();
1304  --Line->Level;
1305  }
1306  if (FormatTok->Tok.is(tok::kw_else)) {
1307  nextToken();
1308  if (FormatTok->Tok.is(tok::l_brace)) {
1309  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1310  parseBlock(/*MustBeDeclaration=*/false);
1311  addUnwrappedLine();
1312  } else if (FormatTok->Tok.is(tok::kw_if)) {
1313  parseIfThenElse();
1314  } else {
1315  addUnwrappedLine();
1316  ++Line->Level;
1317  parseStructuralElement();
1318  --Line->Level;
1319  }
1320  } else if (NeedsUnwrappedLine) {
1321  addUnwrappedLine();
1322  }
1323 }
1324 
1325 void UnwrappedLineParser::parseTryCatch() {
1326  assert(FormatTok->isOneOf(tok::kw_try, tok::kw___try) && "'try' expected");
1327  nextToken();
1328  bool NeedsUnwrappedLine = false;
1329  if (FormatTok->is(tok::colon)) {
1330  // We are in a function try block, what comes is an initializer list.
1331  nextToken();
1332  while (FormatTok->is(tok::identifier)) {
1333  nextToken();
1334  if (FormatTok->is(tok::l_paren))
1335  parseParens();
1336  if (FormatTok->is(tok::comma))
1337  nextToken();
1338  }
1339  }
1340  // Parse try with resource.
1341  if (Style.Language == FormatStyle::LK_Java && FormatTok->is(tok::l_paren)) {
1342  parseParens();
1343  }
1344  if (FormatTok->is(tok::l_brace)) {
1345  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1346  parseBlock(/*MustBeDeclaration=*/false);
1347  if (Style.BraceWrapping.BeforeCatch) {
1348  addUnwrappedLine();
1349  } else {
1350  NeedsUnwrappedLine = true;
1351  }
1352  } else if (!FormatTok->is(tok::kw_catch)) {
1353  // The C++ standard requires a compound-statement after a try.
1354  // If there's none, we try to assume there's a structuralElement
1355  // and try to continue.
1356  addUnwrappedLine();
1357  ++Line->Level;
1358  parseStructuralElement();
1359  --Line->Level;
1360  }
1361  while (1) {
1362  if (FormatTok->is(tok::at))
1363  nextToken();
1364  if (!(FormatTok->isOneOf(tok::kw_catch, Keywords.kw___except,
1365  tok::kw___finally) ||
1366  ((Style.Language == FormatStyle::LK_Java ||
1368  FormatTok->is(Keywords.kw_finally)) ||
1369  (FormatTok->Tok.isObjCAtKeyword(tok::objc_catch) ||
1370  FormatTok->Tok.isObjCAtKeyword(tok::objc_finally))))
1371  break;
1372  nextToken();
1373  while (FormatTok->isNot(tok::l_brace)) {
1374  if (FormatTok->is(tok::l_paren)) {
1375  parseParens();
1376  continue;
1377  }
1378  if (FormatTok->isOneOf(tok::semi, tok::r_brace, tok::eof))
1379  return;
1380  nextToken();
1381  }
1382  NeedsUnwrappedLine = false;
1383  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1384  parseBlock(/*MustBeDeclaration=*/false);
1385  if (Style.BraceWrapping.BeforeCatch)
1386  addUnwrappedLine();
1387  else
1388  NeedsUnwrappedLine = true;
1389  }
1390  if (NeedsUnwrappedLine)
1391  addUnwrappedLine();
1392 }
1393 
1394 void UnwrappedLineParser::parseNamespace() {
1395  assert(FormatTok->Tok.is(tok::kw_namespace) && "'namespace' expected");
1396 
1397  const FormatToken &InitialToken = *FormatTok;
1398  nextToken();
1399  while (FormatTok->isOneOf(tok::identifier, tok::coloncolon))
1400  nextToken();
1401  if (FormatTok->Tok.is(tok::l_brace)) {
1402  if (ShouldBreakBeforeBrace(Style, InitialToken))
1403  addUnwrappedLine();
1404 
1405  bool AddLevel = Style.NamespaceIndentation == FormatStyle::NI_All ||
1407  DeclarationScopeStack.size() > 1);
1408  parseBlock(/*MustBeDeclaration=*/true, AddLevel);
1409  // Munch the semicolon after a namespace. This is more common than one would
1410  // think. Puttin the semicolon into its own line is very ugly.
1411  if (FormatTok->Tok.is(tok::semi))
1412  nextToken();
1413  addUnwrappedLine();
1414  }
1415  // FIXME: Add error handling.
1416 }
1417 
1418 void UnwrappedLineParser::parseNew() {
1419  assert(FormatTok->is(tok::kw_new) && "'new' expected");
1420  nextToken();
1421  if (Style.Language != FormatStyle::LK_Java)
1422  return;
1423 
1424  // In Java, we can parse everything up to the parens, which aren't optional.
1425  do {
1426  // There should not be a ;, { or } before the new's open paren.
1427  if (FormatTok->isOneOf(tok::semi, tok::l_brace, tok::r_brace))
1428  return;
1429 
1430  // Consume the parens.
1431  if (FormatTok->is(tok::l_paren)) {
1432  parseParens();
1433 
1434  // If there is a class body of an anonymous class, consume that as child.
1435  if (FormatTok->is(tok::l_brace))
1436  parseChildBlock();
1437  return;
1438  }
1439  nextToken();
1440  } while (!eof());
1441 }
1442 
1443 void UnwrappedLineParser::parseForOrWhileLoop() {
1444  assert(FormatTok->isOneOf(tok::kw_for, tok::kw_while, TT_ForEachMacro) &&
1445  "'for', 'while' or foreach macro expected");
1446  nextToken();
1447  if (FormatTok->Tok.is(tok::l_paren))
1448  parseParens();
1449  if (FormatTok->Tok.is(tok::l_brace)) {
1450  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1451  parseBlock(/*MustBeDeclaration=*/false);
1452  addUnwrappedLine();
1453  } else {
1454  addUnwrappedLine();
1455  ++Line->Level;
1456  parseStructuralElement();
1457  --Line->Level;
1458  }
1459 }
1460 
1461 void UnwrappedLineParser::parseDoWhile() {
1462  assert(FormatTok->Tok.is(tok::kw_do) && "'do' expected");
1463  nextToken();
1464  if (FormatTok->Tok.is(tok::l_brace)) {
1465  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1466  parseBlock(/*MustBeDeclaration=*/false);
1467  if (Style.BraceWrapping.IndentBraces)
1468  addUnwrappedLine();
1469  } else {
1470  addUnwrappedLine();
1471  ++Line->Level;
1472  parseStructuralElement();
1473  --Line->Level;
1474  }
1475 
1476  // FIXME: Add error handling.
1477  if (!FormatTok->Tok.is(tok::kw_while)) {
1478  addUnwrappedLine();
1479  return;
1480  }
1481 
1482  nextToken();
1483  parseStructuralElement();
1484 }
1485 
1486 void UnwrappedLineParser::parseLabel() {
1487  nextToken();
1488  unsigned OldLineLevel = Line->Level;
1489  if (Line->Level > 1 || (!Line->InPPDirective && Line->Level > 0))
1490  --Line->Level;
1491  if (CommentsBeforeNextToken.empty() && FormatTok->Tok.is(tok::l_brace)) {
1492  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1493  parseBlock(/*MustBeDeclaration=*/false);
1494  if (FormatTok->Tok.is(tok::kw_break)) {
1496  addUnwrappedLine();
1497  parseStructuralElement();
1498  }
1499  addUnwrappedLine();
1500  } else {
1501  if (FormatTok->is(tok::semi))
1502  nextToken();
1503  addUnwrappedLine();
1504  }
1505  Line->Level = OldLineLevel;
1506 }
1507 
1508 void UnwrappedLineParser::parseCaseLabel() {
1509  assert(FormatTok->Tok.is(tok::kw_case) && "'case' expected");
1510  // FIXME: fix handling of complex expressions here.
1511  do {
1512  nextToken();
1513  } while (!eof() && !FormatTok->Tok.is(tok::colon));
1514  parseLabel();
1515 }
1516 
1517 void UnwrappedLineParser::parseSwitch() {
1518  assert(FormatTok->Tok.is(tok::kw_switch) && "'switch' expected");
1519  nextToken();
1520  if (FormatTok->Tok.is(tok::l_paren))
1521  parseParens();
1522  if (FormatTok->Tok.is(tok::l_brace)) {
1523  CompoundStatementIndenter Indenter(this, Style, Line->Level);
1524  parseBlock(/*MustBeDeclaration=*/false);
1525  addUnwrappedLine();
1526  } else {
1527  addUnwrappedLine();
1528  ++Line->Level;
1529  parseStructuralElement();
1530  --Line->Level;
1531  }
1532 }
1533 
1534 void UnwrappedLineParser::parseAccessSpecifier() {
1535  nextToken();
1536  // Understand Qt's slots.
1537  if (FormatTok->isOneOf(Keywords.kw_slots, Keywords.kw_qslots))
1538  nextToken();
1539  // Otherwise, we don't know what it is, and we'd better keep the next token.
1540  if (FormatTok->Tok.is(tok::colon))
1541  nextToken();
1542  addUnwrappedLine();
1543 }
1544 
1545 bool UnwrappedLineParser::parseEnum() {
1546  // Won't be 'enum' for NS_ENUMs.
1547  if (FormatTok->Tok.is(tok::kw_enum))
1548  nextToken();
1549 
1550  // In TypeScript, "enum" can also be used as property name, e.g. in interface
1551  // declarations. An "enum" keyword followed by a colon would be a syntax
1552  // error and thus assume it is just an identifier.
1553  if (Style.Language == FormatStyle::LK_JavaScript && FormatTok->is(tok::colon))
1554  return false;
1555 
1556  // Eat up enum class ...
1557  if (FormatTok->Tok.is(tok::kw_class) || FormatTok->Tok.is(tok::kw_struct))
1558  nextToken();
1559 
1560  while (FormatTok->Tok.getIdentifierInfo() ||
1561  FormatTok->isOneOf(tok::colon, tok::coloncolon, tok::less,
1562  tok::greater, tok::comma, tok::question)) {
1563  nextToken();
1564  // We can have macros or attributes in between 'enum' and the enum name.
1565  if (FormatTok->is(tok::l_paren))
1566  parseParens();
1567  if (FormatTok->is(tok::identifier)) {
1568  nextToken();
1569  // If there are two identifiers in a row, this is likely an elaborate
1570  // return type. In Java, this can be "implements", etc.
1571  if (Style.Language == FormatStyle::LK_Cpp &&
1572  FormatTok->is(tok::identifier))
1573  return false;
1574  }
1575  }
1576 
1577  // Just a declaration or something is wrong.
1578  if (FormatTok->isNot(tok::l_brace))
1579  return true;
1580  FormatTok->BlockKind = BK_Block;
1581 
1582  if (Style.Language == FormatStyle::LK_Java) {
1583  // Java enums are different.
1584  parseJavaEnumBody();
1585  return true;
1586  }
1587  if (Style.Language == FormatStyle::LK_Proto) {
1588  parseBlock(/*MustBeDeclaration=*/true);
1589  return true;
1590  }
1591 
1592  // Parse enum body.
1593  bool HasError = !parseBracedList(/*ContinueOnSemicolons=*/true);
1594  if (HasError) {
1595  if (FormatTok->is(tok::semi))
1596  nextToken();
1597  addUnwrappedLine();
1598  }
1599  return true;
1600 
1601  // There is no addUnwrappedLine() here so that we fall through to parsing a
1602  // structural element afterwards. Thus, in "enum A {} n, m;",
1603  // "} n, m;" will end up in one unwrapped line.
1604 }
1605 
1606 void UnwrappedLineParser::parseJavaEnumBody() {
1607  // Determine whether the enum is simple, i.e. does not have a semicolon or
1608  // constants with class bodies. Simple enums can be formatted like braced
1609  // lists, contracted to a single line, etc.
1610  unsigned StoredPosition = Tokens->getPosition();
1611  bool IsSimple = true;
1612  FormatToken *Tok = Tokens->getNextToken();
1613  while (Tok) {
1614  if (Tok->is(tok::r_brace))
1615  break;
1616  if (Tok->isOneOf(tok::l_brace, tok::semi)) {
1617  IsSimple = false;
1618  break;
1619  }
1620  // FIXME: This will also mark enums with braces in the arguments to enum
1621  // constants as "not simple". This is probably fine in practice, though.
1622  Tok = Tokens->getNextToken();
1623  }
1624  FormatTok = Tokens->setPosition(StoredPosition);
1625 
1626  if (IsSimple) {
1627  parseBracedList();
1628  addUnwrappedLine();
1629  return;
1630  }
1631 
1632  // Parse the body of a more complex enum.
1633  // First add a line for everything up to the "{".
1634  nextToken();
1635  addUnwrappedLine();
1636  ++Line->Level;
1637 
1638  // Parse the enum constants.
1639  while (FormatTok) {
1640  if (FormatTok->is(tok::l_brace)) {
1641  // Parse the constant's class body.
1642  parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/true,
1643  /*MunchSemi=*/false);
1644  } else if (FormatTok->is(tok::l_paren)) {
1645  parseParens();
1646  } else if (FormatTok->is(tok::comma)) {
1647  nextToken();
1648  addUnwrappedLine();
1649  } else if (FormatTok->is(tok::semi)) {
1650  nextToken();
1651  addUnwrappedLine();
1652  break;
1653  } else if (FormatTok->is(tok::r_brace)) {
1654  addUnwrappedLine();
1655  break;
1656  } else {
1657  nextToken();
1658  }
1659  }
1660 
1661  // Parse the class body after the enum's ";" if any.
1662  parseLevel(/*HasOpeningBrace=*/true);
1663  nextToken();
1664  --Line->Level;
1665  addUnwrappedLine();
1666 }
1667 
1668 void UnwrappedLineParser::parseRecord() {
1669  const FormatToken &InitialToken = *FormatTok;
1670  nextToken();
1671 
1672  // The actual identifier can be a nested name specifier, and in macros
1673  // it is often token-pasted.
1674  while (FormatTok->isOneOf(tok::identifier, tok::coloncolon, tok::hashhash,
1675  tok::kw___attribute, tok::kw___declspec,
1676  tok::kw_alignas) ||
1677  ((Style.Language == FormatStyle::LK_Java ||
1679  FormatTok->isOneOf(tok::period, tok::comma))) {
1680  bool IsNonMacroIdentifier =
1681  FormatTok->is(tok::identifier) &&
1682  FormatTok->TokenText != FormatTok->TokenText.upper();
1683  nextToken();
1684  // We can have macros or attributes in between 'class' and the class name.
1685  if (!IsNonMacroIdentifier && FormatTok->Tok.is(tok::l_paren))
1686  parseParens();
1687  }
1688 
1689  // Note that parsing away template declarations here leads to incorrectly
1690  // accepting function declarations as record declarations.
1691  // In general, we cannot solve this problem. Consider:
1692  // class A<int> B() {}
1693  // which can be a function definition or a class definition when B() is a
1694  // macro. If we find enough real-world cases where this is a problem, we
1695  // can parse for the 'template' keyword in the beginning of the statement,
1696  // and thus rule out the record production in case there is no template
1697  // (this would still leave us with an ambiguity between template function
1698  // and class declarations).
1699  if (FormatTok->isOneOf(tok::colon, tok::less)) {
1700  while (!eof()) {
1701  if (FormatTok->is(tok::l_brace)) {
1702  calculateBraceTypes(/*ExpectClassBody=*/true);
1703  if (!tryToParseBracedList())
1704  break;
1705  }
1706  if (FormatTok->Tok.is(tok::semi))
1707  return;
1708  nextToken();
1709  }
1710  }
1711  if (FormatTok->Tok.is(tok::l_brace)) {
1712  if (ShouldBreakBeforeBrace(Style, InitialToken))
1713  addUnwrappedLine();
1714 
1715  parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/true,
1716  /*MunchSemi=*/false);
1717  }
1718  // There is no addUnwrappedLine() here so that we fall through to parsing a
1719  // structural element afterwards. Thus, in "class A {} n, m;",
1720  // "} n, m;" will end up in one unwrapped line.
1721 }
1722 
1723 void UnwrappedLineParser::parseObjCProtocolList() {
1724  assert(FormatTok->Tok.is(tok::less) && "'<' expected.");
1725  do
1726  nextToken();
1727  while (!eof() && FormatTok->Tok.isNot(tok::greater));
1728  nextToken(); // Skip '>'.
1729 }
1730 
1731 void UnwrappedLineParser::parseObjCUntilAtEnd() {
1732  do {
1733  if (FormatTok->Tok.isObjCAtKeyword(tok::objc_end)) {
1734  nextToken();
1735  addUnwrappedLine();
1736  break;
1737  }
1738  if (FormatTok->is(tok::l_brace)) {
1739  parseBlock(/*MustBeDeclaration=*/false);
1740  // In ObjC interfaces, nothing should be following the "}".
1741  addUnwrappedLine();
1742  } else if (FormatTok->is(tok::r_brace)) {
1743  // Ignore stray "}". parseStructuralElement doesn't consume them.
1744  nextToken();
1745  addUnwrappedLine();
1746  } else {
1747  parseStructuralElement();
1748  }
1749  } while (!eof());
1750 }
1751 
1752 void UnwrappedLineParser::parseObjCInterfaceOrImplementation() {
1753  nextToken();
1754  nextToken(); // interface name
1755 
1756  // @interface can be followed by either a base class, or a category.
1757  if (FormatTok->Tok.is(tok::colon)) {
1758  nextToken();
1759  nextToken(); // base class name
1760  } else if (FormatTok->Tok.is(tok::l_paren))
1761  // Skip category, if present.
1762  parseParens();
1763 
1764  if (FormatTok->Tok.is(tok::less))
1765  parseObjCProtocolList();
1766 
1767  if (FormatTok->Tok.is(tok::l_brace)) {
1769  addUnwrappedLine();
1770  parseBlock(/*MustBeDeclaration=*/true);
1771  }
1772 
1773  // With instance variables, this puts '}' on its own line. Without instance
1774  // variables, this ends the @interface line.
1775  addUnwrappedLine();
1776 
1777  parseObjCUntilAtEnd();
1778 }
1779 
1780 void UnwrappedLineParser::parseObjCProtocol() {
1781  nextToken();
1782  nextToken(); // protocol name
1783 
1784  if (FormatTok->Tok.is(tok::less))
1785  parseObjCProtocolList();
1786 
1787  // Check for protocol declaration.
1788  if (FormatTok->Tok.is(tok::semi)) {
1789  nextToken();
1790  return addUnwrappedLine();
1791  }
1792 
1793  addUnwrappedLine();
1794  parseObjCUntilAtEnd();
1795 }
1796 
1797 void UnwrappedLineParser::parseJavaScriptEs6ImportExport() {
1798  assert(FormatTok->isOneOf(Keywords.kw_import, tok::kw_export));
1799  nextToken();
1800 
1801  // Consume the "default" in "export default class/function".
1802  if (FormatTok->is(tok::kw_default))
1803  nextToken();
1804 
1805  // Consume "function" and "default function", so that these get parsed as
1806  // free-standing JS functions, i.e. do not require a trailing semicolon.
1807  if (FormatTok->is(Keywords.kw_function)) {
1808  nextToken();
1809  return;
1810  }
1811 
1812  // Consume the "abstract" in "export abstract class".
1813  if (FormatTok->is(Keywords.kw_abstract))
1814  nextToken();
1815 
1816  if (FormatTok->isOneOf(tok::kw_const, tok::kw_class, tok::kw_enum,
1817  Keywords.kw_interface, Keywords.kw_let,
1818  Keywords.kw_var))
1819  return; // Fall through to parsing the corresponding structure.
1820 
1821  while (!eof() && FormatTok->isNot(tok::semi)) {
1822  if (FormatTok->is(tok::l_brace)) {
1823  FormatTok->BlockKind = BK_Block;
1824  parseBracedList();
1825  } else {
1826  nextToken();
1827  }
1828  }
1829 }
1830 
1831 LLVM_ATTRIBUTE_UNUSED static void printDebugInfo(const UnwrappedLine &Line,
1832  StringRef Prefix = "") {
1833  llvm::dbgs() << Prefix << "Line(" << Line.Level << ")"
1834  << (Line.InPPDirective ? " MACRO" : "") << ": ";
1835  for (std::list<UnwrappedLineNode>::const_iterator I = Line.Tokens.begin(),
1836  E = Line.Tokens.end();
1837  I != E; ++I) {
1838  llvm::dbgs() << I->Tok->Tok.getName() << "[" << I->Tok->Type << "] ";
1839  }
1840  for (std::list<UnwrappedLineNode>::const_iterator I = Line.Tokens.begin(),
1841  E = Line.Tokens.end();
1842  I != E; ++I) {
1843  const UnwrappedLineNode &Node = *I;
1845  I = Node.Children.begin(),
1846  E = Node.Children.end();
1847  I != E; ++I) {
1848  printDebugInfo(*I, "\nChild: ");
1849  }
1850  }
1851  llvm::dbgs() << "\n";
1852 }
1853 
1854 void UnwrappedLineParser::addUnwrappedLine() {
1855  if (Line->Tokens.empty())
1856  return;
1857  DEBUG({
1858  if (CurrentLines == &Lines)
1859  printDebugInfo(*Line);
1860  });
1861  CurrentLines->push_back(std::move(*Line));
1862  Line->Tokens.clear();
1863  if (CurrentLines == &Lines && !PreprocessorDirectives.empty()) {
1864  CurrentLines->append(
1865  std::make_move_iterator(PreprocessorDirectives.begin()),
1866  std::make_move_iterator(PreprocessorDirectives.end()));
1867  PreprocessorDirectives.clear();
1868  }
1869 }
1870 
1871 bool UnwrappedLineParser::eof() const { return FormatTok->Tok.is(tok::eof); }
1872 
1873 bool UnwrappedLineParser::isOnNewLine(const FormatToken &FormatTok) {
1874  return (Line->InPPDirective || FormatTok.HasUnescapedNewline) &&
1875  FormatTok.NewlinesBefore > 0;
1876 }
1877 
1878 void UnwrappedLineParser::flushComments(bool NewlineBeforeNext) {
1879  bool JustComments = Line->Tokens.empty();
1880  for (SmallVectorImpl<FormatToken *>::const_iterator
1881  I = CommentsBeforeNextToken.begin(),
1882  E = CommentsBeforeNextToken.end();
1883  I != E; ++I) {
1884  if (isOnNewLine(**I) && JustComments)
1885  addUnwrappedLine();
1886  pushToken(*I);
1887  }
1888  if (NewlineBeforeNext && JustComments)
1889  addUnwrappedLine();
1890  CommentsBeforeNextToken.clear();
1891 }
1892 
1893 void UnwrappedLineParser::nextToken() {
1894  if (eof())
1895  return;
1896  flushComments(isOnNewLine(*FormatTok));
1897  pushToken(FormatTok);
1898  readToken();
1899 }
1900 
1901 const FormatToken *UnwrappedLineParser::getPreviousToken() {
1902  // FIXME: This is a dirty way to access the previous token. Find a better
1903  // solution.
1904  if (!Line || Line->Tokens.empty())
1905  return nullptr;
1906  return Line->Tokens.back().Tok;
1907 }
1908 
1909 void UnwrappedLineParser::readToken() {
1910  bool CommentsInCurrentLine = true;
1911  do {
1912  FormatTok = Tokens->getNextToken();
1913  assert(FormatTok);
1914  while (!Line->InPPDirective && FormatTok->Tok.is(tok::hash) &&
1915  (FormatTok->HasUnescapedNewline || FormatTok->IsFirst)) {
1916  // If there is an unfinished unwrapped line, we flush the preprocessor
1917  // directives only after that unwrapped line was finished later.
1918  bool SwitchToPreprocessorLines = !Line->Tokens.empty();
1919  ScopedLineState BlockState(*this, SwitchToPreprocessorLines);
1920  // Comments stored before the preprocessor directive need to be output
1921  // before the preprocessor directive, at the same level as the
1922  // preprocessor directive, as we consider them to apply to the directive.
1923  flushComments(isOnNewLine(*FormatTok));
1924  parsePPDirective();
1925  }
1926  while (FormatTok->Type == TT_ConflictStart ||
1927  FormatTok->Type == TT_ConflictEnd ||
1928  FormatTok->Type == TT_ConflictAlternative) {
1929  if (FormatTok->Type == TT_ConflictStart) {
1930  conditionalCompilationStart(/*Unreachable=*/false);
1931  } else if (FormatTok->Type == TT_ConflictAlternative) {
1932  conditionalCompilationAlternative();
1933  } else if (FormatTok->Type == TT_ConflictEnd) {
1934  conditionalCompilationEnd();
1935  }
1936  FormatTok = Tokens->getNextToken();
1937  FormatTok->MustBreakBefore = true;
1938  }
1939 
1940  if (!PPStack.empty() && (PPStack.back() == PP_Unreachable) &&
1941  !Line->InPPDirective) {
1942  continue;
1943  }
1944 
1945  if (!FormatTok->Tok.is(tok::comment))
1946  return;
1947  if (isOnNewLine(*FormatTok) || FormatTok->IsFirst) {
1948  CommentsInCurrentLine = false;
1949  }
1950  if (CommentsInCurrentLine) {
1951  pushToken(FormatTok);
1952  } else {
1953  CommentsBeforeNextToken.push_back(FormatTok);
1954  }
1955  } while (!eof());
1956 }
1957 
1958 void UnwrappedLineParser::pushToken(FormatToken *Tok) {
1959  Line->Tokens.push_back(UnwrappedLineNode(Tok));
1960  if (MustBreakBeforeNextToken) {
1961  Line->Tokens.back().Tok->MustBreakBefore = true;
1962  MustBreakBeforeNextToken = false;
1963  }
1964 }
1965 
1966 } // end namespace format
1967 } // end namespace clang
int Position
SmallVector< UnwrappedLine, 0 > Children
bool AfterUnion
Wrap union definitions.
Definition: Format.h:263
Indent in all namespaces.
Definition: Format.h:454
Should be used for Protocol Buffers (https://developers.google.com/protocol-buffers/).
Definition: Format.h:430
bool IndentCaseLabels
Indent case labels one level from the switch statement.
Definition: Format.h:404
static LLVM_ATTRIBUTE_UNUSED void printDebugInfo(const UnwrappedLine &Line, StringRef Prefix="")
Parser - This implements a parser for the C family of languages.
Definition: Parse/Parser.h:56
Should be used for C, C++, ObjectiveC, ObjectiveC++.
Definition: Format.h:423
UnwrappedLineParser(const FormatStyle &Style, const AdditionalKeywords &Keywords, ArrayRef< FormatToken * > Tokens, UnwrappedLineConsumer &Callback)
FormatToken *& ResetToken
virtual void consumeUnwrappedLine(const UnwrappedLine &Line)=0
unsigned Level
The indent level of the UnwrappedLine.
FormatToken * FormatTok
Definition: Format.cpp:1346
bool AfterObjCDeclaration
Wrap ObjC definitions (, interfaces, ..).
Definition: Format.h:259
bool IndentBraces
Indent the wrapped braces themselves.
Definition: Format.h:269
Should be used for Java.
Definition: Format.h:425
static bool tokenCanStartNewLine(const clang::Token &Tok)
Token - This structure provides full information about a lexed token.
Definition: Token.h:37
AdditionalKeywords Keywords
Definition: Format.cpp:1356
NamespaceIndentationKind NamespaceIndentation
The indentation used for namespaces.
Definition: Format.h:458
static bool isGoogScope(const UnwrappedLine &Line)
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 ...
detail::InMemoryDirectory::const_iterator I
CompoundStatementIndenter(UnwrappedLineParser *Parser, const FormatStyle &Style, unsigned &LineLevel)
AnnotatingParser & P
ScopedLineState(UnwrappedLineParser &Parser, bool SwitchToPreprocessorLines=false)
std::vector< bool > & Stack
FormatTokenSource *& TokenSource
std::list< UnwrappedLineNode > Tokens
The Tokens comprising this UnwrappedLine.
Should be used for JavaScript.
Definition: Format.h:427
ContinuationIndenter * Indenter
MatchFinder::MatchCallback * Callback
StateNode * Previous
bool InPPDirective
Whether this UnwrappedLine is part of a preprocessor directive.
BraceWrappingFlags BraceWrapping
Control of individual brace wrapping cases.
Definition: Format.h:276
bool AfterFunction
Wrap function definitions.
Definition: Format.h:255
A wrapper around a Token storing information about the whitespace characters preceding it...
Definition: FormatToken.h:112
FormatToken * Token
bool isNot(tok::TokenKind K) const
Definition: Token.h:96
#define false
Definition: stdbool.h:33
Encapsulates keywords that are context sensitive or for languages not properly supported by Clang's l...
Definition: FormatToken.h:526
ArrayRef< FormatToken * > Tokens
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
virtual FormatToken * setPosition(unsigned Position)=0
The FormatStyle is used to configure the formatting to follow specific guidelines.
Definition: Format.h:42
static bool ShouldBreakBeforeBrace(const FormatStyle &Style, const FormatToken &InitialToken)
Indent only in inner namespaces (nested in other namespaces).
Definition: Format.h:452
LanguageKind Language
Language, this format style is targeted at.
Definition: Format.h:436
ast_type_traits::DynTypedNode Node
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
UnwrappedLine & Line
Should be used for TableGen code.
Definition: Format.h:432
detail::InMemoryDirectory::const_iterator E
FormatStyle & Style
Definition: Format.cpp:1354
bool AfterStruct
Wrap struct definitions.
Definition: Format.h:261
bool is(tok::TokenKind Kind) const
Definition: FormatToken.h:281
virtual unsigned getPosition()=0
bool AfterControlStatement
Wrap control statements (if/for/while/switch/..).
Definition: Format.h:251
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:43
unsigned PreviousLineLevel
bool MustBreakBefore
Whether there must be a line break before this token.
Definition: FormatToken.h:154
FormatTokenSource * PreviousTokenSource
bool AfterClass
Wrap class definitions.
Definition: Format.h:249
StringRef Text
Definition: Format.cpp:1724
bool AfterNamespace
Wrap namespace definitions.
Definition: Format.h:257