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
21namespace clang {
22namespace format {
23
24class FormatTokenSource {
25public:
26  virtual ~FormatTokenSource() {}
27  virtual FormatToken *getNextToken() = 0;
28
29  virtual unsigned getPosition() = 0;
30  virtual FormatToken *setPosition(unsigned Position) = 0;
31};
32
33namespace {
34
35class ScopedDeclarationState {
36public:
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
51private:
52  UnwrappedLine &Line;
53  std::vector<bool> &Stack;
54};
55
56class ScopedMacroState : public FormatTokenSource {
57public:
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
94private:
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
121class ScopedLineState {
122public:
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
148private:
149  UnwrappedLineParser &Parser;
150
151  UnwrappedLine *PreBlockLine;
152  SmallVectorImpl<UnwrappedLine> *OriginalLines;
153};
154
155class CompoundStatementIndenter {
156public:
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
169private:
170  unsigned &LineLevel;
171  unsigned OldLineLevel;
172};
173
174namespace {
175
176class IndexedTokenSource : public FormatTokenSource {
177public:
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
198private:
199  ArrayRef<FormatToken *> Tokens;
200  int Position;
201};
202
203} // end anonymous namespace
204
205UnwrappedLineParser::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
213void 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
226bool 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
262void 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
272void 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
308void 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
396void 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
422static 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
438void 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
454void 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
490void 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
497void 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
509void 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
520void 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
536void 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
546void UnwrappedLineParser::parsePPElse() {
547  conditionalCompilationAlternative();
548  parsePPUnknown();
549}
550
551void UnwrappedLineParser::parsePPElIf() { parsePPElse(); }
552
553void UnwrappedLineParser::parsePPEndIf() {
554  conditionalCompilationEnd();
555  parsePPUnknown();
556}
557
558void 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
582void 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.
592bool 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
618void 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
819bool 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
865bool 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
911void 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
932bool 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
942bool 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
990void 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
1025void 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
1061void 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
1101void 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
1167void 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
1191void 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
1210void 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
1235void 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
1258void 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
1267void 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
1284void 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
1296void 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
1328void 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
1378void 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
1386void 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
1407void 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
1436void 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
1453LLVM_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
1476void 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
1496bool UnwrappedLineParser::eof() const { return FormatTok->Tok.is(tok::eof); }
1497
1498bool UnwrappedLineParser::isOnNewLine(const FormatToken &FormatTok) {
1499  return (Line->InPPDirective || FormatTok.HasUnescapedNewline) &&
1500         FormatTok.NewlinesBefore > 0;
1501}
1502
1503void 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
1520void UnwrappedLineParser::nextToken() {
1521  if (eof())
1522    return;
1523  flushComments(isOnNewLine(*FormatTok));
1524  pushToken(FormatTok);
1525  readToken();
1526}
1527
1528void 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
1578void 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