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/Support/Debug.h"
  18
  19 #define DEBUG_TYPE "format-parser"
  20
  21 namespace clang {
  22 namespace format {
  23
  24 class FormatTokenSource {
  25 public:
  26   virtual ~FormatTokenSource() {}
  27   virtual FormatToken *getNextToken() = 0;
  28
  29   virtual unsigned getPosition() = 0;
  30   virtual FormatToken *setPosition(unsigned Position) = 0;
  31 };
  32
  33 namespace {
  34
  35 class ScopedDeclarationState {
  36 public:
  37   ScopedDeclarationState(UnwrappedLine &Line, std::vector<bool> &Stack,
  38                          bool MustBeDeclaration)
  39       : Line(Line), Stack(Stack) {
  40     Line.MustBeDeclaration = MustBeDeclaration;
  41     Stack.push_back(MustBeDeclaration);
  42   }
  43   ~ScopedDeclarationState() {
  44     Stack.pop_back();
  45     if (!Stack.empty())
  46       Line.MustBeDeclaration = Stack.back();
  47     else
  48       Line.MustBeDeclaration = true;
  49   }
  50
  51 private:
  52   UnwrappedLine &Line;
  53   std::vector<bool> &Stack;
  54 };
  55
  56 class ScopedMacroState : public FormatTokenSource {
  57 public:
  58   ScopedMacroState(UnwrappedLine &Line, FormatTokenSource *&TokenSource,
  59                    FormatToken *&ResetToken, bool &StructuralError)
  60       : Line(Line), TokenSource(TokenSource), ResetToken(ResetToken),
  61         PreviousLineLevel(Line.Level), PreviousTokenSource(TokenSource),
  62         StructuralError(StructuralError),
  63         PreviousStructuralError(StructuralError), Token(nullptr) {
  64     TokenSource = this;
  65     Line.Level = 0;
  66     Line.InPPDirective = true;
  67   }
  68
  69   ~ScopedMacroState() {
  70     TokenSource = PreviousTokenSource;
  71     ResetToken = Token;
  72     Line.InPPDirective = false;
  73     Line.Level = PreviousLineLevel;
  74     StructuralError = PreviousStructuralError;
  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   bool &StructuralError;
 114   bool PreviousStructuralError;
 115
 116   FormatToken *Token;
 117 };
 118
 119 } // end anonymous namespace
 120
 121 class ScopedLineState {
 122 public:
 123   ScopedLineState(UnwrappedLineParser &Parser,
 124                   bool SwitchToPreprocessorLines = false)
 125       : Parser(Parser) {
 126     OriginalLines = Parser.CurrentLines;
 127     if (SwitchToPreprocessorLines)
 128       Parser.CurrentLines = &Parser.PreprocessorDirectives;
 129     else if (!Parser.Line->Tokens.empty())
 130       Parser.CurrentLines = &Parser.Line->Tokens.back().Children;
 131     PreBlockLine = Parser.Line.release();
 132     Parser.Line.reset(new UnwrappedLine());
 133     Parser.Line->Level = PreBlockLine->Level;
 134     Parser.Line->InPPDirective = PreBlockLine->InPPDirective;
 135   }
 136
 137   ~ScopedLineState() {
 138     if (!Parser.Line->Tokens.empty()) {
 139       Parser.addUnwrappedLine();
 140     }
 141     assert(Parser.Line->Tokens.empty());
 142     Parser.Line.reset(PreBlockLine);
 143     if (Parser.CurrentLines == &Parser.PreprocessorDirectives)
 144       Parser.MustBreakBeforeNextToken = true;
 145     Parser.CurrentLines = OriginalLines;
 146   }
 147
 148 private:
 149   UnwrappedLineParser &Parser;
 150
 151   UnwrappedLine *PreBlockLine;
 152   SmallVectorImpl<UnwrappedLine> *OriginalLines;
 153 };
 154
 155 class CompoundStatementIndenter {
 156 public:
 157   CompoundStatementIndenter(UnwrappedLineParser *Parser,
 158                             const FormatStyle &Style, unsigned &LineLevel)
 159       : LineLevel(LineLevel), OldLineLevel(LineLevel) {
 160     if (Style.BreakBeforeBraces == FormatStyle::BS_Allman) {
 161       Parser->addUnwrappedLine();
 162     } else if (Style.BreakBeforeBraces == FormatStyle::BS_GNU) {
 163       Parser->addUnwrappedLine();
 164       ++LineLevel;
 165     }
 166   }
 167   ~CompoundStatementIndenter() { LineLevel = OldLineLevel; }
 168
 169 private:
 170   unsigned &LineLevel;
 171   unsigned OldLineLevel;
 172 };
 173
 174 namespace {
 175
 176 class IndexedTokenSource : public FormatTokenSource {
 177 public:
 178   IndexedTokenSource(ArrayRef<FormatToken *> Tokens)
 179       : Tokens(Tokens), Position(-1) {}
 180
 181   FormatToken *getNextToken() override {
 182     ++Position;
 183     return Tokens[Position];
 184   }
 185
 186   unsigned getPosition() override {
 187     assert(Position >= 0);
 188     return Position;
 189   }
 190
 191   FormatToken *setPosition(unsigned P) override {
 192     Position = P;
 193     return Tokens[Position];
 194   }
 195
 196   void reset() { Position = -1; }
 197
 198 private:
 199   ArrayRef<FormatToken *> Tokens;
 200   int Position;
 201 };
 202
 203 } // end anonymous namespace
 204
 205 UnwrappedLineParser::UnwrappedLineParser(const FormatStyle &Style,
 206                                          ArrayRef<FormatToken *> Tokens,
 207                                          UnwrappedLineConsumer &Callback)
 208     : Line(new UnwrappedLine), MustBreakBeforeNextToken(false),
 209       CurrentLines(&Lines), StructuralError(false), Style(Style),
 210       Tokens(nullptr), Callback(Callback), AllTokens(Tokens),
 211       PPBranchLevel(-1) {}
 212
 213 void UnwrappedLineParser::reset() {
 214   PPBranchLevel = -1;
 215   Line.reset(new UnwrappedLine);
 216   CommentsBeforeNextToken.clear();
 217   FormatTok = nullptr;
 218   MustBreakBeforeNextToken = false;
 219   PreprocessorDirectives.clear();
 220   CurrentLines = &Lines;
 221   DeclarationScopeStack.clear();
 222   StructuralError = false;
 223   PPStack.clear();
 224 }
 225
 226 bool UnwrappedLineParser::parse() {
 227   IndexedTokenSource TokenSource(AllTokens);
 228   do {
 229     DEBUG(llvm::dbgs() << "----\n");
 230     reset();
 231     Tokens = &TokenSource;
 232     TokenSource.reset();
 233
 234     readToken();
 235     parseFile();
 236     // Create line with eof token.
 237     pushToken(FormatTok);
 238     addUnwrappedLine();
 239
 240     for (SmallVectorImpl<UnwrappedLine>::iterator I = Lines.begin(),
 241                                                   E = Lines.end();
 242          I != E; ++I) {
 243       Callback.consumeUnwrappedLine(*I);
 244     }
 245     Callback.finishRun();
 246     Lines.clear();
 247     while (!PPLevelBranchIndex.empty() &&
 248            PPLevelBranchIndex.back() + 1 >= PPLevelBranchCount.back()) {
 249       PPLevelBranchIndex.resize(PPLevelBranchIndex.size() - 1);
 250       PPLevelBranchCount.resize(PPLevelBranchCount.size() - 1);
 251     }
 252     if (!PPLevelBranchIndex.empty()) {
 253       ++PPLevelBranchIndex.back();
 254       assert(PPLevelBranchIndex.size() == PPLevelBranchCount.size());
 255       assert(PPLevelBranchIndex.back() <= PPLevelBranchCount.back());
 256     }
 257   } while (!PPLevelBranchIndex.empty());
 258
 259   return StructuralError;
 260 }
 261
 262 void UnwrappedLineParser::parseFile() {
 263   ScopedDeclarationState DeclarationState(
 264       *Line, DeclarationScopeStack,
 265       /*MustBeDeclaration=*/ !Line->InPPDirective);
 266   parseLevel(/*HasOpeningBrace=*/false);
 267   // Make sure to format the remaining tokens.
 268   flushComments(true);
 269   addUnwrappedLine();
 270 }
 271
 272 void UnwrappedLineParser::parseLevel(bool HasOpeningBrace) {
 273   bool SwitchLabelEncountered = false;
 274   do {
 275     switch (FormatTok->Tok.getKind()) {
 276     case tok::comment:
 277       nextToken();
 278       addUnwrappedLine();
 279       break;
 280     case tok::l_brace:
 281       // FIXME: Add parameter whether this can happen - if this happens, we must
 282       // be in a non-declaration context.
 283       parseBlock(/*MustBeDeclaration=*/false);
 284       addUnwrappedLine();
 285       break;
 286     case tok::r_brace:
 287       if (HasOpeningBrace)
 288         return;
 289       StructuralError = true;
 290       nextToken();
 291       addUnwrappedLine();
 292       break;
 293     case tok::kw_default:
 294     case tok::kw_case:
 295       if (!SwitchLabelEncountered &&
 296           (Style.IndentCaseLabels || (Line->InPPDirective && Line->Level == 1)))
 297         ++Line->Level;
 298       SwitchLabelEncountered = true;
 299       parseStructuralElement();
 300       break;
 301     default:
 302       parseStructuralElement();
 303       break;
 304     }
 305   } while (!eof());
 306 }
 307
 308 void UnwrappedLineParser::calculateBraceTypes() {
 309   // We'll parse forward through the tokens until we hit
 310   // a closing brace or eof - note that getNextToken() will
 311   // parse macros, so this will magically work inside macro
 312   // definitions, too.
 313   unsigned StoredPosition = Tokens->getPosition();
 314   unsigned Position = StoredPosition;
 315   FormatToken *Tok = FormatTok;
 316   // Keep a stack of positions of lbrace tokens. We will
 317   // update information about whether an lbrace starts a
 318   // braced init list or a different block during the loop.
 319   SmallVector<FormatToken *, 8> LBraceStack;
 320   assert(Tok->Tok.is(tok::l_brace));
 321   do {
 322     // Get next none-comment token.
 323     FormatToken *NextTok;
 324     unsigned ReadTokens = 0;
 325     do {
 326       NextTok = Tokens->getNextToken();
 327       ++ReadTokens;
 328     } while (NextTok->is(tok::comment));
 329
 330     switch (Tok->Tok.getKind()) {
 331     case tok::l_brace:
 332       LBraceStack.push_back(Tok);
 333       break;
 334     case tok::r_brace:
 335       if (!LBraceStack.empty()) {
 336         if (LBraceStack.back()->BlockKind == BK_Unknown) {
 337           bool ProbablyBracedList = false;
 338           if (Style.Language == FormatStyle::LK_Proto) {
 339             ProbablyBracedList = NextTok->isOneOf(tok::comma, tok::r_square);
 340           } else {
 341             // Using OriginalColumn to distinguish between ObjC methods and
 342             // binary operators is a bit hacky.
 343             bool NextIsObjCMethod = NextTok->isOneOf(tok::plus, tok::minus) &&
 344                                     NextTok->OriginalColumn == 0;
 345
 346             // If there is a comma, semicolon or right paren after the closing
 347             // brace, we assume this is a braced initializer list.  Note that
 348             // regardless how we mark inner braces here, we will overwrite the
 349             // BlockKind later if we parse a braced list (where all blocks
 350             // inside are by default braced lists), or when we explicitly detect
 351             // blocks (for example while parsing lambdas).
 352             //
 353             // We exclude + and - as they can be ObjC visibility modifiers.
 354             ProbablyBracedList =
 355                 NextTok->isOneOf(tok::comma, tok::semi, tok::period, tok::colon,
 356                                  tok::r_paren, tok::r_square, tok::l_brace,
 357                                  tok::l_paren) ||
 358                 (NextTok->isBinaryOperator() && !NextIsObjCMethod);
 359           }
 360           if (ProbablyBracedList) {
 361             Tok->BlockKind = BK_BracedInit;
 362             LBraceStack.back()->BlockKind = BK_BracedInit;
 363           } else {
 364             Tok->BlockKind = BK_Block;
 365             LBraceStack.back()->BlockKind = BK_Block;
 366           }
 367         }
 368         LBraceStack.pop_back();
 369       }
 370       break;
 371     case tok::at:
 372     case tok::semi:
 373     case tok::kw_if:
 374     case tok::kw_while:
 375     case tok::kw_for:
 376     case tok::kw_switch:
 377     case tok::kw_try:
 378       if (!LBraceStack.empty())
 379         LBraceStack.back()->BlockKind = BK_Block;
 380       break;
 381     default:
 382       break;
 383     }
 384     Tok = NextTok;
 385     Position += ReadTokens;
 386   } while (Tok->Tok.isNot(tok::eof) && !LBraceStack.empty());
 387   // Assume other blocks for all unclosed opening braces.
 388   for (unsigned i = 0, e = LBraceStack.size(); i != e; ++i) {
 389     if (LBraceStack[i]->BlockKind == BK_Unknown)
 390       LBraceStack[i]->BlockKind = BK_Block;
 391   }
 392
 393   FormatTok = Tokens->setPosition(StoredPosition);
 394 }
 395
 396 void UnwrappedLineParser::parseBlock(bool MustBeDeclaration, bool AddLevel,
 397                                      bool MunchSemi) {
 398   assert(FormatTok->Tok.is(tok::l_brace) && "'{' expected");
 399   unsigned InitialLevel = Line->Level;
 400   nextToken();
 401
 402   addUnwrappedLine();
 403
 404   ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
 405                                           MustBeDeclaration);
 406   if (AddLevel)
 407     ++Line->Level;
 408   parseLevel(/*HasOpeningBrace=*/true);
 409
 410   if (!FormatTok->Tok.is(tok::r_brace)) {
 411     Line->Level = InitialLevel;
 412     StructuralError = true;
 413     return;
 414   }
 415
 416   nextToken(); // Munch the closing brace.
 417   if (MunchSemi && FormatTok->Tok.is(tok::semi))
 418     nextToken();
 419   Line->Level = InitialLevel;
 420 }
 421
 422 static bool IsGoogScope(const UnwrappedLine &Line) {
 423   if (Line.Tokens.size() < 4)
 424     return false;
 425   auto I = Line.Tokens.begin();
 426   if (I->Tok->TokenText != "goog")
 427     return false;
 428   ++I;
 429   if (I->Tok->isNot(tok::period))
 430     return false;
 431   ++I;
 432   if (I->Tok->TokenText != "scope")
 433     return false;
 434   ++I;
 435   return I->Tok->is(tok::l_paren);
 436 }
 437
 438 void UnwrappedLineParser::parseChildBlock() {
 439   FormatTok->BlockKind = BK_Block;
 440   nextToken();
 441   {
 442     bool GoogScope =
 443         Style.Language == FormatStyle::LK_JavaScript && IsGoogScope(*Line);
 444     ScopedLineState LineState(*this);
 445     ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
 446                                             /*MustBeDeclaration=*/false);
 447     Line->Level += GoogScope ? 0 : 1;
 448     parseLevel(/*HasOpeningBrace=*/true);
 449     Line->Level -= GoogScope ? 0 : 1;
 450   }
 451   nextToken();
 452 }
 453
 454 void UnwrappedLineParser::parsePPDirective() {
 455   assert(FormatTok->Tok.is(tok::hash) && "'#' expected");
 456   ScopedMacroState MacroState(*Line, Tokens, FormatTok, StructuralError);
 457   nextToken();
 458
 459   if (!FormatTok->Tok.getIdentifierInfo()) {
 460     parsePPUnknown();
 461     return;
 462   }
 463
 464   switch (FormatTok->Tok.getIdentifierInfo()->getPPKeywordID()) {
 465   case tok::pp_define:
 466     parsePPDefine();
 467     return;
 468   case tok::pp_if:
 469     parsePPIf(/*IfDef=*/false);
 470     break;
 471   case tok::pp_ifdef:
 472   case tok::pp_ifndef:
 473     parsePPIf(/*IfDef=*/true);
 474     break;
 475   case tok::pp_else:
 476     parsePPElse();
 477     break;
 478   case tok::pp_elif:
 479     parsePPElIf();
 480     break;
 481   case tok::pp_endif:
 482     parsePPEndIf();
 483     break;
 484   default:
 485     parsePPUnknown();
 486     break;
 487   }
 488 }
 489
 490 void UnwrappedLineParser::conditionalCompilationCondition(bool Unreachable) {
 491   if (Unreachable || (!PPStack.empty() && PPStack.back() == PP_Unreachable))
 492     PPStack.push_back(PP_Unreachable);
 493   else
 494     PPStack.push_back(PP_Conditional);
 495 }
 496
 497 void UnwrappedLineParser::conditionalCompilationStart(bool Unreachable) {
 498   ++PPBranchLevel;
 499   assert(PPBranchLevel >= 0 && PPBranchLevel <= (int)PPLevelBranchIndex.size());
 500   if (PPBranchLevel == (int)PPLevelBranchIndex.size()) {
 501     PPLevelBranchIndex.push_back(0);
 502     PPLevelBranchCount.push_back(0);
 503   }
 504   PPChainBranchIndex.push(0);
 505   bool Skip = PPLevelBranchIndex[PPBranchLevel] > 0;
 506   conditionalCompilationCondition(Unreachable || Skip);
 507 }
 508
 509 void UnwrappedLineParser::conditionalCompilationAlternative() {
 510   if (!PPStack.empty())
 511     PPStack.pop_back();
 512   assert(PPBranchLevel < (int)PPLevelBranchIndex.size());
 513   if (!PPChainBranchIndex.empty())
 514     ++PPChainBranchIndex.top();
 515   conditionalCompilationCondition(
 516       PPBranchLevel >= 0 && !PPChainBranchIndex.empty() &&
 517       PPLevelBranchIndex[PPBranchLevel] != PPChainBranchIndex.top());
 518 }
 519
 520 void UnwrappedLineParser::conditionalCompilationEnd() {
 521   assert(PPBranchLevel < (int)PPLevelBranchIndex.size());
 522   if (PPBranchLevel >= 0 && !PPChainBranchIndex.empty()) {
 523     if (PPChainBranchIndex.top() + 1 > PPLevelBranchCount[PPBranchLevel]) {
 524       PPLevelBranchCount[PPBranchLevel] = PPChainBranchIndex.top() + 1;
 525     }
 526   }
 527   // Guard against #endif's without #if.
 528   if (PPBranchLevel > 0)
 529     --PPBranchLevel;
 530   if (!PPChainBranchIndex.empty())
 531     PPChainBranchIndex.pop();
 532   if (!PPStack.empty())
 533     PPStack.pop_back();
 534 }
 535
 536 void UnwrappedLineParser::parsePPIf(bool IfDef) {
 537   nextToken();
 538   bool IsLiteralFalse = (FormatTok->Tok.isLiteral() &&
 539                          StringRef(FormatTok->Tok.getLiteralData(),
 540                                    FormatTok->Tok.getLength()) == "0") ||
 541                         FormatTok->Tok.is(tok::kw_false);
 542   conditionalCompilationStart(!IfDef && IsLiteralFalse);
 543   parsePPUnknown();
 544 }
 545
 546 void UnwrappedLineParser::parsePPElse() {
 547   conditionalCompilationAlternative();
 548   parsePPUnknown();
 549 }
 550
 551 void UnwrappedLineParser::parsePPElIf() { parsePPElse(); }
 552
 553 void UnwrappedLineParser::parsePPEndIf() {
 554   conditionalCompilationEnd();
 555   parsePPUnknown();
 556 }
 557
 558 void UnwrappedLineParser::parsePPDefine() {
 559   nextToken();
 560
 561   if (FormatTok->Tok.getKind() != tok::identifier) {
 562     parsePPUnknown();
 563     return;
 564   }
 565   nextToken();
 566   if (FormatTok->Tok.getKind() == tok::l_paren &&
 567       FormatTok->WhitespaceRange.getBegin() ==
 568           FormatTok->WhitespaceRange.getEnd()) {
 569     parseParens();
 570   }
 571   addUnwrappedLine();
 572   Line->Level = 1;
 573
 574   // Errors during a preprocessor directive can only affect the layout of the
 575   // preprocessor directive, and thus we ignore them. An alternative approach
 576   // would be to use the same approach we use on the file level (no
 577   // re-indentation if there was a structural error) within the macro
 578   // definition.
 579   parseFile();
 580 }
 581
 582 void UnwrappedLineParser::parsePPUnknown() {
 583   do {
 584     nextToken();
 585   } while (!eof());
 586   addUnwrappedLine();
 587 }
 588
 589 // Here we blacklist certain tokens that are not usually the first token in an
 590 // unwrapped line. This is used in attempt to distinguish macro calls without
 591 // trailing semicolons from other constructs split to several lines.
 592 bool tokenCanStartNewLine(clang::Token Tok) {
 593   // Semicolon can be a null-statement, l_square can be a start of a macro or
 594   // a C++11 attribute, but this doesn't seem to be common.
 595   return Tok.isNot(tok::semi) && Tok.isNot(tok::l_brace) &&
 596          Tok.isNot(tok::l_square) &&
 597          // Tokens that can only be used as binary operators and a part of
 598          // overloaded operator names.
 599          Tok.isNot(tok::period) && Tok.isNot(tok::periodstar) &&
 600          Tok.isNot(tok::arrow) && Tok.isNot(tok::arrowstar) &&
 601          Tok.isNot(tok::less) && Tok.isNot(tok::greater) &&
 602          Tok.isNot(tok::slash) && Tok.isNot(tok::percent) &&
 603          Tok.isNot(tok::lessless) && Tok.isNot(tok::greatergreater) &&
 604          Tok.isNot(tok::equal) && Tok.isNot(tok::plusequal) &&
 605          Tok.isNot(tok::minusequal) && Tok.isNot(tok::starequal) &&
 606          Tok.isNot(tok::slashequal) && Tok.isNot(tok::percentequal) &&
 607          Tok.isNot(tok::ampequal) && Tok.isNot(tok::pipeequal) &&
 608          Tok.isNot(tok::caretequal) && Tok.isNot(tok::greatergreaterequal) &&
 609          Tok.isNot(tok::lesslessequal) &&
 610          // Colon is used in labels, base class lists, initializer lists,
 611          // range-based for loops, ternary operator, but should never be the
 612          // first token in an unwrapped line.
 613          Tok.isNot(tok::colon) &&
 614          // 'noexcept' is a trailing annotation.
 615          Tok.isNot(tok::kw_noexcept);
 616 }
 617
 618 void UnwrappedLineParser::parseStructuralElement() {
 619   assert(!FormatTok->Tok.is(tok::l_brace));
 620   switch (FormatTok->Tok.getKind()) {
 621   case tok::at:
 622     nextToken();
 623     if (FormatTok->Tok.is(tok::l_brace)) {
 624       parseBracedList();
 625       break;
 626     }
 627     switch (FormatTok->Tok.getObjCKeywordID()) {
 628     case tok::objc_public:
 629     case tok::objc_protected:
 630     case tok::objc_package:
 631     case tok::objc_private:
 632       return parseAccessSpecifier();
 633     case tok::objc_interface:
 634     case tok::objc_implementation:
 635       return parseObjCInterfaceOrImplementation();
 636     case tok::objc_protocol:
 637       return parseObjCProtocol();
 638     case tok::objc_end:
 639       return; // Handled by the caller.
 640     case tok::objc_optional:
 641     case tok::objc_required:
 642       nextToken();
 643       addUnwrappedLine();
 644       return;
 645     default:
 646       break;
 647     }
 648     break;
 649   case tok::kw_namespace:
 650     parseNamespace();
 651     return;
 652   case tok::kw_inline:
 653     nextToken();
 654     if (FormatTok->Tok.is(tok::kw_namespace)) {
 655       parseNamespace();
 656       return;
 657     }
 658     break;
 659   case tok::kw_public:
 660   case tok::kw_protected:
 661   case tok::kw_private:
 662     parseAccessSpecifier();
 663     return;
 664   case tok::kw_if:
 665     parseIfThenElse();
 666     return;
 667   case tok::kw_for:
 668   case tok::kw_while:
 669     parseForOrWhileLoop();
 670     return;
 671   case tok::kw_do:
 672     parseDoWhile();
 673     return;
 674   case tok::kw_switch:
 675     parseSwitch();
 676     return;
 677   case tok::kw_default:
 678     nextToken();
 679     parseLabel();
 680     return;
 681   case tok::kw_case:
 682     parseCaseLabel();
 683     return;
 684   case tok::kw_try:
 685     parseTryCatch();
 686     return;
 687   case tok::kw_extern:
 688     nextToken();
 689     if (FormatTok->Tok.is(tok::string_literal)) {
 690       nextToken();
 691       if (FormatTok->Tok.is(tok::l_brace)) {
 692         parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/false);
 693         addUnwrappedLine();
 694         return;
 695       }
 696     }
 697     break;
 698   case tok::identifier:
 699     if (FormatTok->IsForEachMacro) {
 700       parseForOrWhileLoop();
 701       return;
 702     }
 703     // In all other cases, parse the declaration.
 704     break;
 705   default:
 706     break;
 707   }
 708   do {
 709     switch (FormatTok->Tok.getKind()) {
 710     case tok::at:
 711       nextToken();
 712       if (FormatTok->Tok.is(tok::l_brace))
 713         parseBracedList();
 714       break;
 715     case tok::kw_enum:
 716       parseEnum();
 717       break;
 718     case tok::kw_typedef:
 719       nextToken();
 720       // FIXME: Use the IdentifierTable instead.
 721       if (FormatTok->TokenText == "NS_ENUM")
 722         parseEnum();
 723       break;
 724     case tok::kw_struct:
 725     case tok::kw_union:
 726     case tok::kw_class:
 727       parseRecord();
 728       // A record declaration or definition is always the start of a structural
 729       // element.
 730       break;
 731     case tok::semi:
 732       nextToken();
 733       addUnwrappedLine();
 734       return;
 735     case tok::r_brace:
 736       addUnwrappedLine();
 737       return;
 738     case tok::l_paren:
 739       parseParens();
 740       break;
 741     case tok::caret:
 742       nextToken();
 743       if (FormatTok->Tok.isAnyIdentifier() ||
 744           FormatTok->isSimpleTypeSpecifier())
 745         nextToken();
 746       if (FormatTok->is(tok::l_paren))
 747         parseParens();
 748       if (FormatTok->is(tok::l_brace))
 749         parseChildBlock();
 750       break;
 751     case tok::l_brace:
 752       if (!tryToParseBracedList()) {
 753         // A block outside of parentheses must be the last part of a
 754         // structural element.
 755         // FIXME: Figure out cases where this is not true, and add projections
 756         // for them (the one we know is missing are lambdas).
 757         if (Style.BreakBeforeBraces != FormatStyle::BS_Attach)
 758           addUnwrappedLine();
 759         FormatTok->Type = TT_FunctionLBrace;
 760         parseBlock(/*MustBeDeclaration=*/false);
 761         addUnwrappedLine();
 762         return;
 763       }
 764       // Otherwise this was a braced init list, and the structural
 765       // element continues.
 766       break;
 767     case tok::kw_try:
 768       // We arrive here when parsing function-try blocks.
 769       parseTryCatch();
 770       return;
 771     case tok::identifier: {
 772       StringRef Text = FormatTok->TokenText;
 773       // Parse function literal unless 'function' is the first token in a line
 774       // in which case this should be treated as a free-standing function.
 775       if (Style.Language == FormatStyle::LK_JavaScript && Text == "function" &&
 776           Line->Tokens.size() > 0) {
 777         tryToParseJSFunction();
 778         break;
 779       }
 780       nextToken();
 781       if (Line->Tokens.size() == 1) {
 782         if (FormatTok->Tok.is(tok::colon)) {
 783           parseLabel();
 784           return;
 785         }
 786         // Recognize function-like macro usages without trailing semicolon.
 787         if (FormatTok->Tok.is(tok::l_paren)) {
 788           parseParens();
 789           if (FormatTok->NewlinesBefore > 0 &&
 790               tokenCanStartNewLine(FormatTok->Tok) && Text == Text.upper()) {
 791             addUnwrappedLine();
 792             return;
 793           }
 794         } else if (FormatTok->HasUnescapedNewline && Text.size() >= 5 &&
 795                    Text == Text.upper()) {
 796           // Recognize free-standing macros like Q_OBJECT.
 797           addUnwrappedLine();
 798           return;
 799         }
 800       }
 801       break;
 802     }
 803     case tok::equal:
 804       nextToken();
 805       if (FormatTok->Tok.is(tok::l_brace)) {
 806         parseBracedList();
 807       }
 808       break;
 809     case tok::l_square:
 810       parseSquare();
 811       break;
 812     default:
 813       nextToken();
 814       break;
 815     }
 816   } while (!eof());
 817 }
 818
 819 bool UnwrappedLineParser::tryToParseLambda() {
 820   // FIXME: This is a dirty way to access the previous token. Find a better
 821   // solution.
 822   if (!Line->Tokens.empty() &&
 823       (Line->Tokens.back().Tok->isOneOf(tok::identifier, tok::kw_operator) ||
 824        Line->Tokens.back().Tok->closesScope() ||
 825        Line->Tokens.back().Tok->isSimpleTypeSpecifier())) {
 826     nextToken();
 827     return false;
 828   }
 829   assert(FormatTok->is(tok::l_square));
 830   FormatToken &LSquare = *FormatTok;
 831   if (!tryToParseLambdaIntroducer())
 832     return false;
 833
 834   while (FormatTok->isNot(tok::l_brace)) {
 835     if (FormatTok->isSimpleTypeSpecifier()) {
 836       nextToken();
 837       continue;
 838     }
 839     switch (FormatTok->Tok.getKind()) {
 840     case tok::l_brace:
 841       break;
 842     case tok::l_paren:
 843       parseParens();
 844       break;
 845     case tok::less:
 846     case tok::greater:
 847     case tok::identifier:
 848     case tok::coloncolon:
 849     case tok::kw_mutable:
 850       nextToken();
 851       break;
 852     case tok::arrow:
 853       FormatTok->Type = TT_TrailingReturnArrow;
 854       nextToken();
 855       break;
 856     default:
 857       return true;
 858     }
 859   }
 860   LSquare.Type = TT_LambdaLSquare;
 861   parseChildBlock();
 862   return true;
 863 }
 864
 865 bool UnwrappedLineParser::tryToParseLambdaIntroducer() {
 866   nextToken();
 867   if (FormatTok->is(tok::equal)) {
 868     nextToken();
 869     if (FormatTok->is(tok::r_square)) {
 870       nextToken();
 871       return true;
 872     }
 873     if (FormatTok->isNot(tok::comma))
 874       return false;
 875     nextToken();
 876   } else if (FormatTok->is(tok::amp)) {
 877     nextToken();
 878     if (FormatTok->is(tok::r_square)) {
 879       nextToken();
 880       return true;
 881     }
 882     if (!FormatTok->isOneOf(tok::comma, tok::identifier)) {
 883       return false;
 884     }
 885     if (FormatTok->is(tok::comma))
 886       nextToken();
 887   } else if (FormatTok->is(tok::r_square)) {
 888     nextToken();
 889     return true;
 890   }
 891   do {
 892     if (FormatTok->is(tok::amp))
 893       nextToken();
 894     if (!FormatTok->isOneOf(tok::identifier, tok::kw_this))
 895       return false;
 896     nextToken();
 897     if (FormatTok->is(tok::ellipsis))
 898       nextToken();
 899     if (FormatTok->is(tok::comma)) {
 900       nextToken();
 901     } else if (FormatTok->is(tok::r_square)) {
 902       nextToken();
 903       return true;
 904     } else {
 905       return false;
 906     }
 907   } while (!eof());
 908   return false;
 909 }
 910
 911 void UnwrappedLineParser::tryToParseJSFunction() {
 912   nextToken();
 913
 914   // Consume function name.
 915   if (FormatTok->is(tok::identifier))
 916       nextToken();
 917
 918   if (FormatTok->isNot(tok::l_paren))
 919     return;
 920   nextToken();
 921   while (FormatTok->isNot(tok::l_brace)) {
 922     // Err on the side of caution in order to avoid consuming the full file in
 923     // case of incomplete code.
 924     if (!FormatTok->isOneOf(tok::identifier, tok::comma, tok::r_paren,
 925                             tok::comment))
 926       return;
 927     nextToken();
 928   }
 929   parseChildBlock();
 930 }
 931
 932 bool UnwrappedLineParser::tryToParseBracedList() {
 933   if (FormatTok->BlockKind == BK_Unknown)
 934     calculateBraceTypes();
 935   assert(FormatTok->BlockKind != BK_Unknown);
 936   if (FormatTok->BlockKind == BK_Block)
 937     return false;
 938   parseBracedList();
 939   return true;
 940 }
 941
 942 bool UnwrappedLineParser::parseBracedList(bool ContinueOnSemicolons) {
 943   bool HasError = false;
 944   nextToken();
 945
 946   // FIXME: Once we have an expression parser in the UnwrappedLineParser,
 947   // replace this by using parseAssigmentExpression() inside.
 948   do {
 949     if (Style.Language == FormatStyle::LK_JavaScript &&
 950         FormatTok->TokenText == "function") {
 951       tryToParseJSFunction();
 952       continue;
 953     }
 954     switch (FormatTok->Tok.getKind()) {
 955     case tok::caret:
 956       nextToken();
 957       if (FormatTok->is(tok::l_brace)) {
 958         parseChildBlock();
 959       }
 960       break;
 961     case tok::l_square:
 962       tryToParseLambda();
 963       break;
 964     case tok::l_brace:
 965       // Assume there are no blocks inside a braced init list apart
 966       // from the ones we explicitly parse out (like lambdas).
 967       FormatTok->BlockKind = BK_BracedInit;
 968       parseBracedList();
 969       break;
 970     case tok::r_brace:
 971       nextToken();
 972       return !HasError;
 973     case tok::semi:
 974       HasError = true;
 975       if (!ContinueOnSemicolons)
 976         return !HasError;
 977       nextToken();
 978       break;
 979     case tok::comma:
 980       nextToken();
 981       break;
 982     default:
 983       nextToken();
 984       break;
 985     }
 986   } while (!eof());
 987   return false;
 988 }
 989
 990 void UnwrappedLineParser::parseParens() {
 991   assert(FormatTok->Tok.is(tok::l_paren) && "'(' expected.");
 992   nextToken();
 993   do {
 994     switch (FormatTok->Tok.getKind()) {
 995     case tok::l_paren:
 996       parseParens();
 997       break;
 998     case tok::r_paren:
 999       nextToken();
1000       return;
1001     case tok::r_brace:
1002       // A "}" inside parenthesis is an error if there wasn't a matching "{".
1003       return;
1004     case tok::l_square:
1005       tryToParseLambda();
1006       break;
1007     case tok::l_brace: {
1008       if (!tryToParseBracedList()) {
1009         parseChildBlock();
1010       }
1011       break;
1012     }
1013     case tok::at:
1014       nextToken();
1015       if (FormatTok->Tok.is(tok::l_brace))
1016         parseBracedList();
1017       break;
1018     default:
1019       nextToken();
1020       break;
1021     }
1022   } while (!eof());
1023 }
1024
1025 void UnwrappedLineParser::parseSquare() {
1026   assert(FormatTok->Tok.is(tok::l_square) && "'[' expected.");
1027   if (tryToParseLambda())
1028     return;
1029   do {
1030     switch (FormatTok->Tok.getKind()) {
1031     case tok::l_paren:
1032       parseParens();
1033       break;
1034     case tok::r_square:
1035       nextToken();
1036       return;
1037     case tok::r_brace:
1038       // A "}" inside parenthesis is an error if there wasn't a matching "{".
1039       return;
1040     case tok::l_square:
1041       parseSquare();
1042       break;
1043     case tok::l_brace: {
1044       if (!tryToParseBracedList()) {
1045         parseChildBlock();
1046       }
1047       break;
1048     }
1049     case tok::at:
1050       nextToken();
1051       if (FormatTok->Tok.is(tok::l_brace))
1052         parseBracedList();
1053       break;
1054     default:
1055       nextToken();
1056       break;
1057     }
1058   } while (!eof());
1059 }
1060
1061 void UnwrappedLineParser::parseIfThenElse() {
1062   assert(FormatTok->Tok.is(tok::kw_if) && "'if' expected");
1063   nextToken();
1064   if (FormatTok->Tok.is(tok::l_paren))
1065     parseParens();
1066   bool NeedsUnwrappedLine = false;
1067   if (FormatTok->Tok.is(tok::l_brace)) {
1068     CompoundStatementIndenter Indenter(this, Style, Line->Level);
1069     parseBlock(/*MustBeDeclaration=*/false);
1070     if (Style.BreakBeforeBraces == FormatStyle::BS_Allman ||
1071         Style.BreakBeforeBraces == FormatStyle::BS_GNU) {
1072       addUnwrappedLine();
1073     } else {
1074       NeedsUnwrappedLine = true;
1075     }
1076   } else {
1077     addUnwrappedLine();
1078     ++Line->Level;
1079     parseStructuralElement();
1080     --Line->Level;
1081   }
1082   if (FormatTok->Tok.is(tok::kw_else)) {
1083     nextToken();
1084     if (FormatTok->Tok.is(tok::l_brace)) {
1085       CompoundStatementIndenter Indenter(this, Style, Line->Level);
1086       parseBlock(/*MustBeDeclaration=*/false);
1087       addUnwrappedLine();
1088     } else if (FormatTok->Tok.is(tok::kw_if)) {
1089       parseIfThenElse();
1090     } else {
1091       addUnwrappedLine();
1092       ++Line->Level;
1093       parseStructuralElement();
1094       --Line->Level;
1095     }
1096   } else if (NeedsUnwrappedLine) {
1097     addUnwrappedLine();
1098   }
1099 }
1100
1101 void UnwrappedLineParser::parseTryCatch() {
1102   assert(FormatTok->is(tok::kw_try) && "'try' expected");
1103   nextToken();
1104   bool NeedsUnwrappedLine = false;
1105   if (FormatTok->is(tok::colon)) {
1106     // We are in a function try block, what comes is an initializer list.
1107     nextToken();
1108     while (FormatTok->is(tok::identifier)) {
1109       nextToken();
1110       if (FormatTok->is(tok::l_paren))
1111         parseParens();
1112       else
1113         StructuralError = true;
1114       if (FormatTok->is(tok::comma))
1115         nextToken();
1116     }
1117   }
1118   if (FormatTok->is(tok::l_brace)) {
1119     CompoundStatementIndenter Indenter(this, Style, Line->Level);
1120     parseBlock(/*MustBeDeclaration=*/false);
1121     if (Style.BreakBeforeBraces == FormatStyle::BS_Allman ||
1122         Style.BreakBeforeBraces == FormatStyle::BS_GNU ||
1123         Style.BreakBeforeBraces == FormatStyle::BS_Stroustrup) {
1124       addUnwrappedLine();
1125     } else {
1126       NeedsUnwrappedLine = true;
1127     }
1128   } else if (!FormatTok->is(tok::kw_catch)) {
1129     // The C++ standard requires a compound-statement after a try.
1130     // If there's none, we try to assume there's a structuralElement
1131     // and try to continue.
1132     StructuralError = true;
1133     addUnwrappedLine();
1134     ++Line->Level;
1135     parseStructuralElement();
1136     --Line->Level;
1137   }
1138   while (FormatTok->is(tok::kw_catch) ||
1139          (Style.Language == FormatStyle::LK_JavaScript &&
1140           FormatTok->TokenText == "finally")) {
1141     nextToken();
1142     while (FormatTok->isNot(tok::l_brace)) {
1143       if (FormatTok->is(tok::l_paren)) {
1144         parseParens();
1145         continue;
1146       }
1147       if (FormatTok->isOneOf(tok::semi, tok::r_brace))
1148         return;
1149       nextToken();
1150     }
1151     NeedsUnwrappedLine = false;
1152     CompoundStatementIndenter Indenter(this, Style, Line->Level);
1153     parseBlock(/*MustBeDeclaration=*/false);
1154     if (Style.BreakBeforeBraces == FormatStyle::BS_Allman ||
1155         Style.BreakBeforeBraces == FormatStyle::BS_GNU ||
1156         Style.BreakBeforeBraces == FormatStyle::BS_Stroustrup) {
1157       addUnwrappedLine();
1158     } else {
1159       NeedsUnwrappedLine = true;
1160     }
1161   }
1162   if (NeedsUnwrappedLine) {
1163     addUnwrappedLine();
1164   }
1165 }
1166
1167 void UnwrappedLineParser::parseNamespace() {
1168   assert(FormatTok->Tok.is(tok::kw_namespace) && "'namespace' expected");
1169   nextToken();
1170   if (FormatTok->Tok.is(tok::identifier))
1171     nextToken();
1172   if (FormatTok->Tok.is(tok::l_brace)) {
1173     if (Style.BreakBeforeBraces == FormatStyle::BS_Linux ||
1174         Style.BreakBeforeBraces == FormatStyle::BS_Allman ||
1175         Style.BreakBeforeBraces == FormatStyle::BS_GNU)
1176       addUnwrappedLine();
1177
1178     bool AddLevel = Style.NamespaceIndentation == FormatStyle::NI_All ||
1179                     (Style.NamespaceIndentation == FormatStyle::NI_Inner &&
1180                      DeclarationScopeStack.size() > 1);
1181     parseBlock(/*MustBeDeclaration=*/true, AddLevel);
1182     // Munch the semicolon after a namespace. This is more common than one would
1183     // think. Puttin the semicolon into its own line is very ugly.
1184     if (FormatTok->Tok.is(tok::semi))
1185       nextToken();
1186     addUnwrappedLine();
1187   }
1188   // FIXME: Add error handling.
1189 }
1190
1191 void UnwrappedLineParser::parseForOrWhileLoop() {
1192   assert((FormatTok->Tok.is(tok::kw_for) || FormatTok->Tok.is(tok::kw_while) ||
1193           FormatTok->IsForEachMacro) &&
1194          "'for', 'while' or foreach macro expected");
1195   nextToken();
1196   if (FormatTok->Tok.is(tok::l_paren))
1197     parseParens();
1198   if (FormatTok->Tok.is(tok::l_brace)) {
1199     CompoundStatementIndenter Indenter(this, Style, Line->Level);
1200     parseBlock(/*MustBeDeclaration=*/false);
1201     addUnwrappedLine();
1202   } else {
1203     addUnwrappedLine();
1204     ++Line->Level;
1205     parseStructuralElement();
1206     --Line->Level;
1207   }
1208 }
1209
1210 void UnwrappedLineParser::parseDoWhile() {
1211   assert(FormatTok->Tok.is(tok::kw_do) && "'do' expected");
1212   nextToken();
1213   if (FormatTok->Tok.is(tok::l_brace)) {
1214     CompoundStatementIndenter Indenter(this, Style, Line->Level);
1215     parseBlock(/*MustBeDeclaration=*/false);
1216     if (Style.BreakBeforeBraces == FormatStyle::BS_GNU)
1217       addUnwrappedLine();
1218   } else {
1219     addUnwrappedLine();
1220     ++Line->Level;
1221     parseStructuralElement();
1222     --Line->Level;
1223   }
1224
1225   // FIXME: Add error handling.
1226   if (!FormatTok->Tok.is(tok::kw_while)) {
1227     addUnwrappedLine();
1228     return;
1229   }
1230
1231   nextToken();
1232   parseStructuralElement();
1233 }
1234
1235 void UnwrappedLineParser::parseLabel() {
1236   nextToken();
1237   unsigned OldLineLevel = Line->Level;
1238   if (Line->Level > 1 || (!Line->InPPDirective && Line->Level > 0))
1239     --Line->Level;
1240   if (CommentsBeforeNextToken.empty() && FormatTok->Tok.is(tok::l_brace)) {
1241     CompoundStatementIndenter Indenter(this, Style, Line->Level);
1242     parseBlock(/*MustBeDeclaration=*/false);
1243     if (FormatTok->Tok.is(tok::kw_break)) {
1244       // "break;" after "}" on its own line only for BS_Allman and BS_GNU
1245       if (Style.BreakBeforeBraces == FormatStyle::BS_Allman ||
1246           Style.BreakBeforeBraces == FormatStyle::BS_GNU) {
1247         addUnwrappedLine();
1248       }
1249       parseStructuralElement();
1250     }
1251     addUnwrappedLine();
1252   } else {
1253     addUnwrappedLine();
1254   }
1255   Line->Level = OldLineLevel;
1256 }
1257
1258 void UnwrappedLineParser::parseCaseLabel() {
1259   assert(FormatTok->Tok.is(tok::kw_case) && "'case' expected");
1260   // FIXME: fix handling of complex expressions here.
1261   do {
1262     nextToken();
1263   } while (!eof() && !FormatTok->Tok.is(tok::colon));
1264   parseLabel();
1265 }
1266
1267 void UnwrappedLineParser::parseSwitch() {
1268   assert(FormatTok->Tok.is(tok::kw_switch) && "'switch' expected");
1269   nextToken();
1270   if (FormatTok->Tok.is(tok::l_paren))
1271     parseParens();
1272   if (FormatTok->Tok.is(tok::l_brace)) {
1273     CompoundStatementIndenter Indenter(this, Style, Line->Level);
1274     parseBlock(/*MustBeDeclaration=*/false);
1275     addUnwrappedLine();
1276   } else {
1277     addUnwrappedLine();
1278     ++Line->Level;
1279     parseStructuralElement();
1280     --Line->Level;
1281   }
1282 }
1283
1284 void UnwrappedLineParser::parseAccessSpecifier() {
1285   nextToken();
1286   // Understand Qt's slots.
1287   if (FormatTok->is(tok::identifier) &&
1288       (FormatTok->TokenText == "slots" || FormatTok->TokenText == "Q_SLOTS"))
1289     nextToken();
1290   // Otherwise, we don't know what it is, and we'd better keep the next token.
1291   if (FormatTok->Tok.is(tok::colon))
1292     nextToken();
1293   addUnwrappedLine();
1294 }
1295
1296 void UnwrappedLineParser::parseEnum() {
1297   if (FormatTok->Tok.is(tok::kw_enum)) {
1298     // Won't be 'enum' for NS_ENUMs.
1299     nextToken();
1300   }
1301   // Eat up enum class ...
1302   if (FormatTok->Tok.is(tok::kw_class) || FormatTok->Tok.is(tok::kw_struct))
1303     nextToken();
1304   while (FormatTok->Tok.getIdentifierInfo() ||
1305          FormatTok->isOneOf(tok::colon, tok::coloncolon)) {
1306     nextToken();
1307     // We can have macros or attributes in between 'enum' and the enum name.
1308     if (FormatTok->Tok.is(tok::l_paren)) {
1309       parseParens();
1310     }
1311     if (FormatTok->Tok.is(tok::identifier))
1312       nextToken();
1313   }
1314   if (FormatTok->Tok.is(tok::l_brace)) {
1315     FormatTok->BlockKind = BK_Block;
1316     bool HasError = !parseBracedList(/*ContinueOnSemicolons=*/true);
1317     if (HasError) {
1318       if (FormatTok->is(tok::semi))
1319         nextToken();
1320       addUnwrappedLine();
1321     }
1322   }
1323   // We fall through to parsing a structural element afterwards, so that in
1324   // enum A {} n, m;
1325   // "} n, m;" will end up in one unwrapped line.
1326 }
1327
1328 void UnwrappedLineParser::parseRecord() {
1329   nextToken();
1330   if (FormatTok->Tok.is(tok::identifier) ||
1331       FormatTok->Tok.is(tok::kw___attribute) ||
1332       FormatTok->Tok.is(tok::kw___declspec) ||
1333       FormatTok->Tok.is(tok::kw_alignas)) {
1334     nextToken();
1335     // We can have macros or attributes in between 'class' and the class name.
1336     if (FormatTok->Tok.is(tok::l_paren)) {
1337       parseParens();
1338     }
1339     // The actual identifier can be a nested name specifier, and in macros
1340     // it is often token-pasted.
1341     while (FormatTok->Tok.is(tok::identifier) ||
1342            FormatTok->Tok.is(tok::coloncolon) ||
1343            FormatTok->Tok.is(tok::hashhash))
1344       nextToken();
1345
1346     // Note that parsing away template declarations here leads to incorrectly
1347     // accepting function declarations as record declarations.
1348     // In general, we cannot solve this problem. Consider:
1349     // class A<int> B() {}
1350     // which can be a function definition or a class definition when B() is a
1351     // macro. If we find enough real-world cases where this is a problem, we
1352     // can parse for the 'template' keyword in the beginning of the statement,
1353     // and thus rule out the record production in case there is no template
1354     // (this would still leave us with an ambiguity between template function
1355     // and class declarations).
1356     if (FormatTok->Tok.is(tok::colon) || FormatTok->Tok.is(tok::less)) {
1357       while (!eof() && FormatTok->Tok.isNot(tok::l_brace)) {
1358         if (FormatTok->Tok.is(tok::semi))
1359           return;
1360         nextToken();
1361       }
1362     }
1363   }
1364   if (FormatTok->Tok.is(tok::l_brace)) {
1365     if (Style.BreakBeforeBraces == FormatStyle::BS_Linux ||
1366         Style.BreakBeforeBraces == FormatStyle::BS_Allman ||
1367         Style.BreakBeforeBraces == FormatStyle::BS_GNU)
1368       addUnwrappedLine();
1369
1370     parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/true,
1371                /*MunchSemi=*/false);
1372   }
1373   // We fall through to parsing a structural element afterwards, so
1374   // class A {} n, m;
1375   // will end up in one unwrapped line.
1376 }
1377
1378 void UnwrappedLineParser::parseObjCProtocolList() {
1379   assert(FormatTok->Tok.is(tok::less) && "'<' expected.");
1380   do
1381     nextToken();
1382   while (!eof() && FormatTok->Tok.isNot(tok::greater));
1383   nextToken(); // Skip '>'.
1384 }
1385
1386 void UnwrappedLineParser::parseObjCUntilAtEnd() {
1387   do {
1388     if (FormatTok->Tok.isObjCAtKeyword(tok::objc_end)) {
1389       nextToken();
1390       addUnwrappedLine();
1391       break;
1392     }
1393     if (FormatTok->is(tok::l_brace)) {
1394       parseBlock(/*MustBeDeclaration=*/false);
1395       // In ObjC interfaces, nothing should be following the "}".
1396       addUnwrappedLine();
1397     } else if (FormatTok->is(tok::r_brace)) {
1398       // Ignore stray "}". parseStructuralElement doesn't consume them.
1399       nextToken();
1400       addUnwrappedLine();
1401     } else {
1402       parseStructuralElement();
1403     }
1404   } while (!eof());
1405 }
1406
1407 void UnwrappedLineParser::parseObjCInterfaceOrImplementation() {
1408   nextToken();
1409   nextToken(); // interface name
1410
1411   // @interface can be followed by either a base class, or a category.
1412   if (FormatTok->Tok.is(tok::colon)) {
1413     nextToken();
1414     nextToken(); // base class name
1415   } else if (FormatTok->Tok.is(tok::l_paren))
1416     // Skip category, if present.
1417     parseParens();
1418
1419   if (FormatTok->Tok.is(tok::less))
1420     parseObjCProtocolList();
1421
1422   if (FormatTok->Tok.is(tok::l_brace)) {
1423     if (Style.BreakBeforeBraces == FormatStyle::BS_Allman ||
1424         Style.BreakBeforeBraces == FormatStyle::BS_GNU)
1425       addUnwrappedLine();
1426     parseBlock(/*MustBeDeclaration=*/true);
1427   }
1428
1429   // With instance variables, this puts '}' on its own line.  Without instance
1430   // variables, this ends the @interface line.
1431   addUnwrappedLine();
1432
1433   parseObjCUntilAtEnd();
1434 }
1435
1436 void UnwrappedLineParser::parseObjCProtocol() {
1437   nextToken();
1438   nextToken(); // protocol name
1439
1440   if (FormatTok->Tok.is(tok::less))
1441     parseObjCProtocolList();
1442
1443   // Check for protocol declaration.
1444   if (FormatTok->Tok.is(tok::semi)) {
1445     nextToken();
1446     return addUnwrappedLine();
1447   }
1448
1449   addUnwrappedLine();
1450   parseObjCUntilAtEnd();
1451 }
1452
1453 LLVM_ATTRIBUTE_UNUSED static void printDebugInfo(const UnwrappedLine &Line,
1454                                                  StringRef Prefix = "") {
1455   llvm::dbgs() << Prefix << "Line(" << Line.Level << ")"
1456                << (Line.InPPDirective ? " MACRO" : "") << ": ";
1457   for (std::list<UnwrappedLineNode>::const_iterator I = Line.Tokens.begin(),
1458                                                     E = Line.Tokens.end();
1459        I != E; ++I) {
1460     llvm::dbgs() << I->Tok->Tok.getName() << "[" << I->Tok->Type << "] ";
1461   }
1462   for (std::list<UnwrappedLineNode>::const_iterator I = Line.Tokens.begin(),
1463                                                     E = Line.Tokens.end();
1464        I != E; ++I) {
1465     const UnwrappedLineNode &Node = *I;
1466     for (SmallVectorImpl<UnwrappedLine>::const_iterator
1467              I = Node.Children.begin(),
1468              E = Node.Children.end();
1469          I != E; ++I) {
1470       printDebugInfo(*I, "\nChild: ");
1471     }
1472   }
1473   llvm::dbgs() << "\n";
1474 }
1475
1476 void UnwrappedLineParser::addUnwrappedLine() {
1477   if (Line->Tokens.empty())
1478     return;
1479   DEBUG({
1480     if (CurrentLines == &Lines)
1481       printDebugInfo(*Line);
1482   });
1483   CurrentLines->push_back(*Line);
1484   Line->Tokens.clear();
1485   if (CurrentLines == &Lines && !PreprocessorDirectives.empty()) {
1486     for (SmallVectorImpl<UnwrappedLine>::iterator
1487              I = PreprocessorDirectives.begin(),
1488              E = PreprocessorDirectives.end();
1489          I != E; ++I) {
1490       CurrentLines->push_back(*I);
1491     }
1492     PreprocessorDirectives.clear();
1493   }
1494 }
1495
1496 bool UnwrappedLineParser::eof() const { return FormatTok->Tok.is(tok::eof); }
1497
1498 bool UnwrappedLineParser::isOnNewLine(const FormatToken &FormatTok) {
1499   return (Line->InPPDirective || FormatTok.HasUnescapedNewline) &&
1500          FormatTok.NewlinesBefore > 0;
1501 }
1502
1503 void UnwrappedLineParser::flushComments(bool NewlineBeforeNext) {
1504   bool JustComments = Line->Tokens.empty();
1505   for (SmallVectorImpl<FormatToken *>::const_iterator
1506            I = CommentsBeforeNextToken.begin(),
1507            E = CommentsBeforeNextToken.end();
1508        I != E; ++I) {
1509     if (isOnNewLine(**I) && JustComments) {
1510       addUnwrappedLine();
1511     }
1512     pushToken(*I);
1513   }
1514   if (NewlineBeforeNext && JustComments) {
1515     addUnwrappedLine();
1516   }
1517   CommentsBeforeNextToken.clear();
1518 }
1519
1520 void UnwrappedLineParser::nextToken() {
1521   if (eof())
1522     return;
1523   flushComments(isOnNewLine(*FormatTok));
1524   pushToken(FormatTok);
1525   readToken();
1526 }
1527
1528 void UnwrappedLineParser::readToken() {
1529   bool CommentsInCurrentLine = true;
1530   do {
1531     FormatTok = Tokens->getNextToken();
1532     assert(FormatTok);
1533     while (!Line->InPPDirective && FormatTok->Tok.is(tok::hash) &&
1534            (FormatTok->HasUnescapedNewline || FormatTok->IsFirst)) {
1535       // If there is an unfinished unwrapped line, we flush the preprocessor
1536       // directives only after that unwrapped line was finished later.
1537       bool SwitchToPreprocessorLines =
1538           !Line->Tokens.empty() && CurrentLines == &Lines;
1539       ScopedLineState BlockState(*this, SwitchToPreprocessorLines);
1540       // Comments stored before the preprocessor directive need to be output
1541       // before the preprocessor directive, at the same level as the
1542       // preprocessor directive, as we consider them to apply to the directive.
1543       flushComments(isOnNewLine(*FormatTok));
1544       parsePPDirective();
1545     }
1546     while (FormatTok->Type == TT_ConflictStart ||
1547            FormatTok->Type == TT_ConflictEnd ||
1548            FormatTok->Type == TT_ConflictAlternative) {
1549       if (FormatTok->Type == TT_ConflictStart) {
1550         conditionalCompilationStart(/*Unreachable=*/false);
1551       } else if (FormatTok->Type == TT_ConflictAlternative) {
1552         conditionalCompilationAlternative();
1553       } else if (FormatTok->Type == TT_ConflictEnd) {
1554         conditionalCompilationEnd();
1555       }
1556       FormatTok = Tokens->getNextToken();
1557       FormatTok->MustBreakBefore = true;
1558     }
1559
1560     if (!PPStack.empty() && (PPStack.back() == PP_Unreachable) &&
1561         !Line->InPPDirective) {
1562       continue;
1563     }
1564
1565     if (!FormatTok->Tok.is(tok::comment))
1566       return;
1567     if (isOnNewLine(*FormatTok) || FormatTok->IsFirst) {
1568       CommentsInCurrentLine = false;
1569     }
1570     if (CommentsInCurrentLine) {
1571       pushToken(FormatTok);
1572     } else {
1573       CommentsBeforeNextToken.push_back(FormatTok);
1574     }
1575   } while (!eof());
1576 }
1577
1578 void UnwrappedLineParser::pushToken(FormatToken *Tok) {
1579   Line->Tokens.push_back(UnwrappedLineNode(Tok));
1580   if (MustBreakBeforeNextToken) {
1581     Line->Tokens.back().Tok->MustBreakBefore = true;
1582     MustBreakBeforeNextToken = false;
1583   }
1584 }
1585
1586 } // end namespace format
1587 } // end namespace clang