contrib/llvm/tools/clang/lib/Format/UnwrappedLineParser.cpp

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