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