Home | History | Annotate | Download | only in Format 
      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
   1588