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