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