blob: 8fc3b78aee01060d2495a3feeb59feddd5c40ece [file] [log] [blame]
Daniel Jasperf7935112012-12-03 18:12:45 +00001//===--- 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///
Daniel Jasperf7935112012-12-03 18:12:45 +000014//===----------------------------------------------------------------------===//
15
Chandler Carruth4b417452013-01-19 08:09:44 +000016#include "UnwrappedLineParser.h"
Benjamin Kramer33335df2015-03-01 21:36:40 +000017#include "llvm/ADT/STLExtras.h"
Manuel Klimekab3dc002013-01-16 12:31:12 +000018#include "llvm/Support/Debug.h"
Benjamin Kramer53f5e892015-03-23 18:05:43 +000019#include "llvm/Support/raw_ostream.h"
Manuel Klimekab3dc002013-01-16 12:31:12 +000020
Chandler Carruth10346662014-04-22 03:17:02 +000021#define DEBUG_TYPE "format-parser"
22
Daniel Jasperf7935112012-12-03 18:12:45 +000023namespace clang {
24namespace format {
25
Manuel Klimek15dfe7a2013-05-28 11:55:06 +000026class FormatTokenSource {
27public:
Angel Garcia Gomez637d1e62015-10-20 13:23:58 +000028 virtual ~FormatTokenSource() {}
Manuel Klimek15dfe7a2013-05-28 11:55:06 +000029 virtual FormatToken *getNextToken() = 0;
30
31 virtual unsigned getPosition() = 0;
32 virtual FormatToken *setPosition(unsigned Position) = 0;
33};
34
Craig Topper69665e12013-07-01 04:21:54 +000035namespace {
36
Manuel Klimek0a3a3c92013-01-23 09:32:48 +000037class ScopedDeclarationState {
38public:
39 ScopedDeclarationState(UnwrappedLine &Line, std::vector<bool> &Stack,
40 bool MustBeDeclaration)
41 : Line(Line), Stack(Stack) {
Manuel Klimek0a3a3c92013-01-23 09:32:48 +000042 Line.MustBeDeclaration = MustBeDeclaration;
Manuel Klimek39080572013-01-23 11:03:04 +000043 Stack.push_back(MustBeDeclaration);
Manuel Klimek0a3a3c92013-01-23 09:32:48 +000044 }
45 ~ScopedDeclarationState() {
Manuel Klimek0a3a3c92013-01-23 09:32:48 +000046 Stack.pop_back();
Manuel Klimekc1237a82013-01-23 14:08:21 +000047 if (!Stack.empty())
48 Line.MustBeDeclaration = Stack.back();
49 else
50 Line.MustBeDeclaration = true;
Manuel Klimek0a3a3c92013-01-23 09:32:48 +000051 }
Daniel Jasper393564f2013-05-31 14:56:29 +000052
Manuel Klimek0a3a3c92013-01-23 09:32:48 +000053private:
54 UnwrappedLine &Line;
55 std::vector<bool> &Stack;
56};
57
Manuel Klimek1abf7892013-01-04 23:34:14 +000058class ScopedMacroState : public FormatTokenSource {
59public:
60 ScopedMacroState(UnwrappedLine &Line, FormatTokenSource *&TokenSource,
Manuel Klimek20e0af62015-05-06 11:56:29 +000061 FormatToken *&ResetToken)
Manuel Klimek1abf7892013-01-04 23:34:14 +000062 : Line(Line), TokenSource(TokenSource), ResetToken(ResetToken),
Manuel Klimek1a18c402013-04-12 14:13:36 +000063 PreviousLineLevel(Line.Level), PreviousTokenSource(TokenSource),
Manuel Klimek20e0af62015-05-06 11:56:29 +000064 Token(nullptr) {
Manuel Klimek1abf7892013-01-04 23:34:14 +000065 TokenSource = this;
Manuel Klimekef2cfb12013-01-05 22:14:16 +000066 Line.Level = 0;
Manuel Klimek1abf7892013-01-04 23:34:14 +000067 Line.InPPDirective = true;
68 }
69
Alexander Kornienko34eb2072015-04-11 02:00:23 +000070 ~ScopedMacroState() override {
Manuel Klimek1abf7892013-01-04 23:34:14 +000071 TokenSource = PreviousTokenSource;
72 ResetToken = Token;
73 Line.InPPDirective = false;
Manuel Klimekef2cfb12013-01-05 22:14:16 +000074 Line.Level = PreviousLineLevel;
Manuel Klimek1abf7892013-01-04 23:34:14 +000075 }
76
Craig Topperfb6b25b2014-03-15 04:29:04 +000077 FormatToken *getNextToken() override {
Manuel Klimek78725712013-01-07 10:03:37 +000078 // The \c UnwrappedLineParser guards against this by never calling
79 // \c getNextToken() after it has encountered the first eof token.
80 assert(!eof());
Manuel Klimek1abf7892013-01-04 23:34:14 +000081 Token = PreviousTokenSource->getNextToken();
82 if (eof())
Manuel Klimek15dfe7a2013-05-28 11:55:06 +000083 return getFakeEOF();
Manuel Klimek1abf7892013-01-04 23:34:14 +000084 return Token;
85 }
86
Craig Topperfb6b25b2014-03-15 04:29:04 +000087 unsigned getPosition() override { return PreviousTokenSource->getPosition(); }
Manuel Klimekab419912013-05-23 09:41:43 +000088
Craig Topperfb6b25b2014-03-15 04:29:04 +000089 FormatToken *setPosition(unsigned Position) override {
Manuel Klimekab419912013-05-23 09:41:43 +000090 Token = PreviousTokenSource->setPosition(Position);
91 return Token;
92 }
93
Manuel Klimek1abf7892013-01-04 23:34:14 +000094private:
Manuel Klimek15dfe7a2013-05-28 11:55:06 +000095 bool eof() { return Token && Token->HasUnescapedNewline; }
Manuel Klimek1abf7892013-01-04 23:34:14 +000096
Manuel Klimek15dfe7a2013-05-28 11:55:06 +000097 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;
Manuel Klimek1abf7892013-01-04 23:34:14 +0000106 }
107
108 UnwrappedLine &Line;
109 FormatTokenSource *&TokenSource;
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000110 FormatToken *&ResetToken;
Manuel Klimekef2cfb12013-01-05 22:14:16 +0000111 unsigned PreviousLineLevel;
Manuel Klimek1abf7892013-01-04 23:34:14 +0000112 FormatTokenSource *PreviousTokenSource;
113
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000114 FormatToken *Token;
Manuel Klimek1abf7892013-01-04 23:34:14 +0000115};
116
Craig Topper69665e12013-07-01 04:21:54 +0000117} // end anonymous namespace
118
Manuel Klimek8e07a1b2013-01-10 11:52:21 +0000119class ScopedLineState {
120public:
Manuel Klimekd3b92fa2013-01-18 14:04:34 +0000121 ScopedLineState(UnwrappedLineParser &Parser,
122 bool SwitchToPreprocessorLines = false)
David Blaikieefb6eb22014-08-09 20:02:07 +0000123 : Parser(Parser), OriginalLines(Parser.CurrentLines) {
Manuel Klimekd3b92fa2013-01-18 14:04:34 +0000124 if (SwitchToPreprocessorLines)
125 Parser.CurrentLines = &Parser.PreprocessorDirectives;
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +0000126 else if (!Parser.Line->Tokens.empty())
127 Parser.CurrentLines = &Parser.Line->Tokens.back().Children;
David Blaikieefb6eb22014-08-09 20:02:07 +0000128 PreBlockLine = std::move(Parser.Line);
129 Parser.Line = llvm::make_unique<UnwrappedLine>();
Daniel Jasperdaffc0d2013-01-16 09:10:19 +0000130 Parser.Line->Level = PreBlockLine->Level;
131 Parser.Line->InPPDirective = PreBlockLine->InPPDirective;
Manuel Klimek8e07a1b2013-01-10 11:52:21 +0000132 }
133
134 ~ScopedLineState() {
Daniel Jasperdaffc0d2013-01-16 09:10:19 +0000135 if (!Parser.Line->Tokens.empty()) {
Manuel Klimek8e07a1b2013-01-10 11:52:21 +0000136 Parser.addUnwrappedLine();
137 }
Daniel Jasperdaffc0d2013-01-16 09:10:19 +0000138 assert(Parser.Line->Tokens.empty());
David Blaikieefb6eb22014-08-09 20:02:07 +0000139 Parser.Line = std::move(PreBlockLine);
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +0000140 if (Parser.CurrentLines == &Parser.PreprocessorDirectives)
141 Parser.MustBreakBeforeNextToken = true;
142 Parser.CurrentLines = OriginalLines;
Manuel Klimek8e07a1b2013-01-10 11:52:21 +0000143 }
144
145private:
146 UnwrappedLineParser &Parser;
147
David Blaikieefb6eb22014-08-09 20:02:07 +0000148 std::unique_ptr<UnwrappedLine> PreBlockLine;
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +0000149 SmallVectorImpl<UnwrappedLine> *OriginalLines;
Manuel Klimek8e07a1b2013-01-10 11:52:21 +0000150};
151
Alexander Kornienko3a33f022013-12-12 09:49:52 +0000152class CompoundStatementIndenter {
153public:
154 CompoundStatementIndenter(UnwrappedLineParser *Parser,
155 const FormatStyle &Style, unsigned &LineLevel)
156 : LineLevel(LineLevel), OldLineLevel(LineLevel) {
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000157 if (Style.BraceWrapping.AfterControlStatement)
Alexander Kornienko3a33f022013-12-12 09:49:52 +0000158 Parser->addUnwrappedLine();
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000159 if (Style.BraceWrapping.IndentBraces)
Alexander Kornienko3a33f022013-12-12 09:49:52 +0000160 ++LineLevel;
Alexander Kornienko3a33f022013-12-12 09:49:52 +0000161 }
Daniel Jasperb05a81d2014-05-09 13:11:16 +0000162 ~CompoundStatementIndenter() { LineLevel = OldLineLevel; }
Alexander Kornienko3a33f022013-12-12 09:49:52 +0000163
164private:
165 unsigned &LineLevel;
166 unsigned OldLineLevel;
167};
168
Craig Topper69665e12013-07-01 04:21:54 +0000169namespace {
170
Manuel Klimekab419912013-05-23 09:41:43 +0000171class IndexedTokenSource : public FormatTokenSource {
172public:
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000173 IndexedTokenSource(ArrayRef<FormatToken *> Tokens)
Manuel Klimekab419912013-05-23 09:41:43 +0000174 : Tokens(Tokens), Position(-1) {}
175
Craig Topperfb6b25b2014-03-15 04:29:04 +0000176 FormatToken *getNextToken() override {
Manuel Klimekab419912013-05-23 09:41:43 +0000177 ++Position;
178 return Tokens[Position];
179 }
180
Craig Topperfb6b25b2014-03-15 04:29:04 +0000181 unsigned getPosition() override {
Manuel Klimekab419912013-05-23 09:41:43 +0000182 assert(Position >= 0);
183 return Position;
184 }
185
Craig Topperfb6b25b2014-03-15 04:29:04 +0000186 FormatToken *setPosition(unsigned P) override {
Manuel Klimekab419912013-05-23 09:41:43 +0000187 Position = P;
188 return Tokens[Position];
189 }
190
Manuel Klimek71814b42013-10-11 21:25:45 +0000191 void reset() { Position = -1; }
192
Manuel Klimekab419912013-05-23 09:41:43 +0000193private:
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000194 ArrayRef<FormatToken *> Tokens;
Manuel Klimekab419912013-05-23 09:41:43 +0000195 int Position;
196};
197
Craig Topper69665e12013-07-01 04:21:54 +0000198} // end anonymous namespace
199
Daniel Jasperd2ae41a2013-05-15 08:14:19 +0000200UnwrappedLineParser::UnwrappedLineParser(const FormatStyle &Style,
Daniel Jasperd0ec0d62014-11-04 12:41:02 +0000201 const AdditionalKeywords &Keywords,
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000202 ArrayRef<FormatToken *> Tokens,
Daniel Jasperd2ae41a2013-05-15 08:14:19 +0000203 UnwrappedLineConsumer &Callback)
Daniel Jasperb05a81d2014-05-09 13:11:16 +0000204 : Line(new UnwrappedLine), MustBreakBeforeNextToken(false),
Manuel Klimek20e0af62015-05-06 11:56:29 +0000205 CurrentLines(&Lines), Style(Style), Keywords(Keywords), Tokens(nullptr),
206 Callback(Callback), AllTokens(Tokens), PPBranchLevel(-1) {}
Manuel Klimek71814b42013-10-11 21:25:45 +0000207
208void UnwrappedLineParser::reset() {
209 PPBranchLevel = -1;
210 Line.reset(new UnwrappedLine);
211 CommentsBeforeNextToken.clear();
Craig Topper2145bc02014-05-09 08:15:10 +0000212 FormatTok = nullptr;
Manuel Klimek71814b42013-10-11 21:25:45 +0000213 MustBreakBeforeNextToken = false;
214 PreprocessorDirectives.clear();
215 CurrentLines = &Lines;
216 DeclarationScopeStack.clear();
Manuel Klimek71814b42013-10-11 21:25:45 +0000217 PPStack.clear();
218}
Daniel Jasperf7935112012-12-03 18:12:45 +0000219
Manuel Klimek20e0af62015-05-06 11:56:29 +0000220void UnwrappedLineParser::parse() {
Manuel Klimekab419912013-05-23 09:41:43 +0000221 IndexedTokenSource TokenSource(AllTokens);
Manuel Klimek71814b42013-10-11 21:25:45 +0000222 do {
223 DEBUG(llvm::dbgs() << "----\n");
224 reset();
225 Tokens = &TokenSource;
226 TokenSource.reset();
Daniel Jaspera79064a2013-03-01 18:11:39 +0000227
Manuel Klimek71814b42013-10-11 21:25:45 +0000228 readToken();
229 parseFile();
230 // Create line with eof token.
231 pushToken(FormatTok);
232 addUnwrappedLine();
233
234 for (SmallVectorImpl<UnwrappedLine>::iterator I = Lines.begin(),
235 E = Lines.end();
236 I != E; ++I) {
237 Callback.consumeUnwrappedLine(*I);
238 }
239 Callback.finishRun();
240 Lines.clear();
241 while (!PPLevelBranchIndex.empty() &&
Daniel Jasper53bd1672013-10-12 13:32:56 +0000242 PPLevelBranchIndex.back() + 1 >= PPLevelBranchCount.back()) {
Manuel Klimek71814b42013-10-11 21:25:45 +0000243 PPLevelBranchIndex.resize(PPLevelBranchIndex.size() - 1);
244 PPLevelBranchCount.resize(PPLevelBranchCount.size() - 1);
245 }
246 if (!PPLevelBranchIndex.empty()) {
247 ++PPLevelBranchIndex.back();
248 assert(PPLevelBranchIndex.size() == PPLevelBranchCount.size());
249 assert(PPLevelBranchIndex.back() <= PPLevelBranchCount.back());
250 }
251 } while (!PPLevelBranchIndex.empty());
Manuel Klimek1abf7892013-01-04 23:34:14 +0000252}
253
Manuel Klimek1a18c402013-04-12 14:13:36 +0000254void UnwrappedLineParser::parseFile() {
Daniel Jasper9326f912015-05-05 08:40:32 +0000255 // The top-level context in a file always has declarations, except for pre-
256 // processor directives and JavaScript files.
257 bool MustBeDeclaration =
258 !Line->InPPDirective && Style.Language != FormatStyle::LK_JavaScript;
259 ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
260 MustBeDeclaration);
Nico Weber9096fc02013-06-26 00:30:14 +0000261 parseLevel(/*HasOpeningBrace=*/false);
Manuel Klimek1abf7892013-01-04 23:34:14 +0000262 // Make sure to format the remaining tokens.
Manuel Klimekf92f7bc2013-01-22 16:31:55 +0000263 flushComments(true);
Manuel Klimek1abf7892013-01-04 23:34:14 +0000264 addUnwrappedLine();
Daniel Jasperf7935112012-12-03 18:12:45 +0000265}
266
Manuel Klimek1a18c402013-04-12 14:13:36 +0000267void UnwrappedLineParser::parseLevel(bool HasOpeningBrace) {
Daniel Jasper516d7972013-07-25 11:31:57 +0000268 bool SwitchLabelEncountered = false;
Daniel Jasperf7935112012-12-03 18:12:45 +0000269 do {
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +0000270 tok::TokenKind kind = FormatTok->Tok.getKind();
271 if (FormatTok->Type == TT_MacroBlockBegin) {
272 kind = tok::l_brace;
273 } else if (FormatTok->Type == TT_MacroBlockEnd) {
274 kind = tok::r_brace;
275 }
276
277 switch (kind) {
Daniel Jasperf7935112012-12-03 18:12:45 +0000278 case tok::comment:
Daniel Jaspere25509f2012-12-17 11:29:41 +0000279 nextToken();
280 addUnwrappedLine();
Daniel Jasperf7935112012-12-03 18:12:45 +0000281 break;
282 case tok::l_brace:
Manuel Klimek0a3a3c92013-01-23 09:32:48 +0000283 // FIXME: Add parameter whether this can happen - if this happens, we must
284 // be in a non-declaration context.
Daniel Jasperb86e2722015-08-24 13:23:37 +0000285 if (!FormatTok->is(TT_MacroBlockBegin) && tryToParseBracedList())
286 continue;
Nico Weber9096fc02013-06-26 00:30:14 +0000287 parseBlock(/*MustBeDeclaration=*/false);
Daniel Jasperf7935112012-12-03 18:12:45 +0000288 addUnwrappedLine();
289 break;
290 case tok::r_brace:
Manuel Klimek1a18c402013-04-12 14:13:36 +0000291 if (HasOpeningBrace)
292 return;
Manuel Klimek1a18c402013-04-12 14:13:36 +0000293 nextToken();
294 addUnwrappedLine();
Manuel Klimek1058d982013-01-06 20:07:31 +0000295 break;
Daniel Jasper516d7972013-07-25 11:31:57 +0000296 case tok::kw_default:
297 case tok::kw_case:
Daniel Jasper72407622013-09-02 08:26:29 +0000298 if (!SwitchLabelEncountered &&
299 (Style.IndentCaseLabels || (Line->InPPDirective && Line->Level == 1)))
300 ++Line->Level;
Daniel Jasper516d7972013-07-25 11:31:57 +0000301 SwitchLabelEncountered = true;
302 parseStructuralElement();
303 break;
Daniel Jasperf7935112012-12-03 18:12:45 +0000304 default:
Manuel Klimek6b9eeba2013-01-07 14:56:16 +0000305 parseStructuralElement();
Daniel Jasperf7935112012-12-03 18:12:45 +0000306 break;
307 }
308 } while (!eof());
309}
310
Daniel Jasperadba2aa2015-05-18 12:52:00 +0000311void UnwrappedLineParser::calculateBraceTypes(bool ExpectClassBody) {
Manuel Klimekab419912013-05-23 09:41:43 +0000312 // We'll parse forward through the tokens until we hit
313 // a closing brace or eof - note that getNextToken() will
314 // parse macros, so this will magically work inside macro
315 // definitions, too.
316 unsigned StoredPosition = Tokens->getPosition();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000317 FormatToken *Tok = FormatTok;
Daniel Jasperb9a49902016-01-09 15:56:28 +0000318 const FormatToken *PrevTok = getPreviousToken();
Manuel Klimekab419912013-05-23 09:41:43 +0000319 // Keep a stack of positions of lbrace tokens. We will
320 // update information about whether an lbrace starts a
321 // braced init list or a different block during the loop.
Daniel Jasperb1f74a82013-07-09 09:06:29 +0000322 SmallVector<FormatToken *, 8> LBraceStack;
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000323 assert(Tok->Tok.is(tok::l_brace));
Manuel Klimekab419912013-05-23 09:41:43 +0000324 do {
Daniel Jaspereb65e912015-12-21 18:31:15 +0000325 // Get next non-comment token.
Daniel Jasper7f5d53e2013-07-01 09:15:46 +0000326 FormatToken *NextTok;
Daniel Jasperca7bd722013-07-01 16:43:38 +0000327 unsigned ReadTokens = 0;
Daniel Jasper7f5d53e2013-07-01 09:15:46 +0000328 do {
329 NextTok = Tokens->getNextToken();
Daniel Jasperca7bd722013-07-01 16:43:38 +0000330 ++ReadTokens;
Daniel Jasper7f5d53e2013-07-01 09:15:46 +0000331 } while (NextTok->is(tok::comment));
332
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000333 switch (Tok->Tok.getKind()) {
Manuel Klimekab419912013-05-23 09:41:43 +0000334 case tok::l_brace:
Daniel Jasperb9a49902016-01-09 15:56:28 +0000335 if (Style.Language == FormatStyle::LK_JavaScript && PrevTok &&
336 PrevTok->is(tok::colon))
337 // In TypeScript's TypeMemberLists, there can be semicolons between the
338 // individual members.
339 Tok->BlockKind = BK_BracedInit;
340 else
341 Tok->BlockKind = BK_Unknown;
Daniel Jasperb1f74a82013-07-09 09:06:29 +0000342 LBraceStack.push_back(Tok);
Manuel Klimekab419912013-05-23 09:41:43 +0000343 break;
344 case tok::r_brace:
Daniel Jasperb9a49902016-01-09 15:56:28 +0000345 if (LBraceStack.empty())
346 break;
347 if (LBraceStack.back()->BlockKind == BK_Unknown) {
348 bool ProbablyBracedList = false;
349 if (Style.Language == FormatStyle::LK_Proto) {
350 ProbablyBracedList = NextTok->isOneOf(tok::comma, tok::r_square);
351 } else {
352 // Using OriginalColumn to distinguish between ObjC methods and
353 // binary operators is a bit hacky.
354 bool NextIsObjCMethod = NextTok->isOneOf(tok::plus, tok::minus) &&
355 NextTok->OriginalColumn == 0;
Daniel Jasper91b032a2014-05-22 12:46:38 +0000356
Daniel Jasperb9a49902016-01-09 15:56:28 +0000357 // If there is a comma, semicolon or right paren after the closing
358 // brace, we assume this is a braced initializer list. Note that
359 // regardless how we mark inner braces here, we will overwrite the
360 // BlockKind later if we parse a braced list (where all blocks
361 // inside are by default braced lists), or when we explicitly detect
362 // blocks (for example while parsing lambdas).
Daniel Jasperb9a49902016-01-09 15:56:28 +0000363 ProbablyBracedList =
Daniel Jasperacffeb82016-03-05 18:34:26 +0000364 (Style.Language == FormatStyle::LK_JavaScript &&
Martin Probste1e12a72016-08-19 14:35:01 +0000365 NextTok->isOneOf(Keywords.kw_of, Keywords.kw_in,
366 Keywords.kw_as)) ||
Daniel Jasperb9a49902016-01-09 15:56:28 +0000367 NextTok->isOneOf(tok::comma, tok::period, tok::colon,
368 tok::r_paren, tok::r_square, tok::l_brace,
369 tok::l_square, tok::l_paren, tok::ellipsis) ||
Daniel Jaspere4ada022016-12-13 10:05:03 +0000370 (NextTok->is(tok::identifier) &&
371 !PrevTok->isOneOf(tok::semi, tok::r_brace, tok::l_brace)) ||
Daniel Jasperb9a49902016-01-09 15:56:28 +0000372 (NextTok->is(tok::semi) &&
373 (!ExpectClassBody || LBraceStack.size() != 1)) ||
374 (NextTok->isBinaryOperator() && !NextIsObjCMethod);
Manuel Klimekab419912013-05-23 09:41:43 +0000375 }
Daniel Jasperb9a49902016-01-09 15:56:28 +0000376 if (ProbablyBracedList) {
377 Tok->BlockKind = BK_BracedInit;
378 LBraceStack.back()->BlockKind = BK_BracedInit;
379 } else {
380 Tok->BlockKind = BK_Block;
381 LBraceStack.back()->BlockKind = BK_Block;
382 }
Manuel Klimekab419912013-05-23 09:41:43 +0000383 }
Daniel Jasperb9a49902016-01-09 15:56:28 +0000384 LBraceStack.pop_back();
Manuel Klimekab419912013-05-23 09:41:43 +0000385 break;
Daniel Jasperac7e34e2014-03-13 10:11:17 +0000386 case tok::at:
Manuel Klimekab419912013-05-23 09:41:43 +0000387 case tok::semi:
388 case tok::kw_if:
389 case tok::kw_while:
390 case tok::kw_for:
391 case tok::kw_switch:
392 case tok::kw_try:
Nico Weberfac23712015-02-04 15:26:27 +0000393 case tok::kw___try:
Daniel Jasperb9a49902016-01-09 15:56:28 +0000394 if (!LBraceStack.empty() && LBraceStack.back()->BlockKind == BK_Unknown)
Daniel Jasperb1f74a82013-07-09 09:06:29 +0000395 LBraceStack.back()->BlockKind = BK_Block;
Manuel Klimekab419912013-05-23 09:41:43 +0000396 break;
397 default:
398 break;
399 }
Daniel Jasperb9a49902016-01-09 15:56:28 +0000400 PrevTok = Tok;
Manuel Klimekab419912013-05-23 09:41:43 +0000401 Tok = NextTok;
Manuel Klimekbab25fd2013-09-04 08:20:47 +0000402 } while (Tok->Tok.isNot(tok::eof) && !LBraceStack.empty());
Daniel Jasperb9a49902016-01-09 15:56:28 +0000403
Manuel Klimekab419912013-05-23 09:41:43 +0000404 // Assume other blocks for all unclosed opening braces.
405 for (unsigned i = 0, e = LBraceStack.size(); i != e; ++i) {
Daniel Jasperb1f74a82013-07-09 09:06:29 +0000406 if (LBraceStack[i]->BlockKind == BK_Unknown)
407 LBraceStack[i]->BlockKind = BK_Block;
Manuel Klimekab419912013-05-23 09:41:43 +0000408 }
Manuel Klimekbab25fd2013-09-04 08:20:47 +0000409
Manuel Klimekab419912013-05-23 09:41:43 +0000410 FormatTok = Tokens->setPosition(StoredPosition);
411}
412
Manuel Klimekb212f3b2013-10-12 22:46:56 +0000413void UnwrappedLineParser::parseBlock(bool MustBeDeclaration, bool AddLevel,
414 bool MunchSemi) {
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +0000415 assert(FormatTok->isOneOf(tok::l_brace, TT_MacroBlockBegin) &&
416 "'{' or macro block token expected");
417 const bool MacroBlock = FormatTok->is(TT_MacroBlockBegin);
Daniel Jaspereb65e912015-12-21 18:31:15 +0000418 FormatTok->BlockKind = BK_Block;
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +0000419
Daniel Jasper516d7972013-07-25 11:31:57 +0000420 unsigned InitialLevel = Line->Level;
Daniel Jasperf7935112012-12-03 18:12:45 +0000421 nextToken();
422
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +0000423 if (MacroBlock && FormatTok->is(tok::l_paren))
424 parseParens();
425
Manuel Klimeka4fe1c12013-01-21 16:42:44 +0000426 addUnwrappedLine();
Daniel Jasperf7935112012-12-03 18:12:45 +0000427
Manuel Klimek0a3a3c92013-01-23 09:32:48 +0000428 ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
429 MustBeDeclaration);
Daniel Jasper65ee3472013-07-31 23:16:02 +0000430 if (AddLevel)
431 ++Line->Level;
Nico Weber9096fc02013-06-26 00:30:14 +0000432 parseLevel(/*HasOpeningBrace=*/true);
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000433
Marianne Mailhot-Sarrasin03137c62016-04-14 14:56:49 +0000434 if (eof())
435 return;
436
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +0000437 if (MacroBlock ? !FormatTok->is(TT_MacroBlockEnd)
438 : !FormatTok->is(tok::r_brace)) {
Daniel Jasper516d7972013-07-25 11:31:57 +0000439 Line->Level = InitialLevel;
Daniel Jaspereb65e912015-12-21 18:31:15 +0000440 FormatTok->BlockKind = BK_Block;
Manuel Klimek1a18c402013-04-12 14:13:36 +0000441 return;
Manuel Klimekf92f7bc2013-01-22 16:31:55 +0000442 }
Alexander Kornienko0ea8e102012-12-04 15:40:36 +0000443
Daniel Jasperd1ae3582013-03-20 12:37:50 +0000444 nextToken(); // Munch the closing brace.
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +0000445
446 if (MacroBlock && FormatTok->is(tok::l_paren))
447 parseParens();
448
Manuel Klimekb212f3b2013-10-12 22:46:56 +0000449 if (MunchSemi && FormatTok->Tok.is(tok::semi))
450 nextToken();
Daniel Jasper516d7972013-07-25 11:31:57 +0000451 Line->Level = InitialLevel;
Daniel Jasperf7935112012-12-03 18:12:45 +0000452}
453
Daniel Jasper02c7bca2015-03-30 09:56:50 +0000454static bool isGoogScope(const UnwrappedLine &Line) {
Daniel Jasper616de8642014-11-23 16:46:28 +0000455 // FIXME: Closure-library specific stuff should not be hard-coded but be
456 // configurable.
Daniel Jasper4a39c842014-05-06 13:54:10 +0000457 if (Line.Tokens.size() < 4)
458 return false;
459 auto I = Line.Tokens.begin();
460 if (I->Tok->TokenText != "goog")
461 return false;
462 ++I;
463 if (I->Tok->isNot(tok::period))
464 return false;
465 ++I;
466 if (I->Tok->TokenText != "scope")
467 return false;
468 ++I;
469 return I->Tok->is(tok::l_paren);
470}
471
Roman Kashitsyna043ced2014-08-11 12:18:01 +0000472static bool ShouldBreakBeforeBrace(const FormatStyle &Style,
473 const FormatToken &InitialToken) {
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000474 if (InitialToken.is(tok::kw_namespace))
475 return Style.BraceWrapping.AfterNamespace;
476 if (InitialToken.is(tok::kw_class))
477 return Style.BraceWrapping.AfterClass;
478 if (InitialToken.is(tok::kw_union))
479 return Style.BraceWrapping.AfterUnion;
480 if (InitialToken.is(tok::kw_struct))
481 return Style.BraceWrapping.AfterStruct;
482 return false;
Roman Kashitsyna043ced2014-08-11 12:18:01 +0000483}
484
Manuel Klimek516e0542013-09-04 13:25:30 +0000485void UnwrappedLineParser::parseChildBlock() {
486 FormatTok->BlockKind = BK_Block;
487 nextToken();
488 {
Daniel Jasper4a39c842014-05-06 13:54:10 +0000489 bool GoogScope =
Daniel Jasper02c7bca2015-03-30 09:56:50 +0000490 Style.Language == FormatStyle::LK_JavaScript && isGoogScope(*Line);
Manuel Klimek516e0542013-09-04 13:25:30 +0000491 ScopedLineState LineState(*this);
492 ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
493 /*MustBeDeclaration=*/false);
Daniel Jasper4a39c842014-05-06 13:54:10 +0000494 Line->Level += GoogScope ? 0 : 1;
Manuel Klimek516e0542013-09-04 13:25:30 +0000495 parseLevel(/*HasOpeningBrace=*/true);
Daniel Jasper02c7bca2015-03-30 09:56:50 +0000496 flushComments(isOnNewLine(*FormatTok));
Daniel Jasper4a39c842014-05-06 13:54:10 +0000497 Line->Level -= GoogScope ? 0 : 1;
Manuel Klimek516e0542013-09-04 13:25:30 +0000498 }
499 nextToken();
500}
501
Daniel Jasperf7935112012-12-03 18:12:45 +0000502void UnwrappedLineParser::parsePPDirective() {
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000503 assert(FormatTok->Tok.is(tok::hash) && "'#' expected");
Manuel Klimek20e0af62015-05-06 11:56:29 +0000504 ScopedMacroState MacroState(*Line, Tokens, FormatTok);
Manuel Klimeka71e5d82013-01-02 16:30:12 +0000505 nextToken();
506
Craig Topper2145bc02014-05-09 08:15:10 +0000507 if (!FormatTok->Tok.getIdentifierInfo()) {
Manuel Klimek591b5802013-01-31 15:58:48 +0000508 parsePPUnknown();
Manuel Klimeka71e5d82013-01-02 16:30:12 +0000509 return;
Daniel Jasperf7935112012-12-03 18:12:45 +0000510 }
Manuel Klimeka71e5d82013-01-02 16:30:12 +0000511
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000512 switch (FormatTok->Tok.getIdentifierInfo()->getPPKeywordID()) {
Manuel Klimek1abf7892013-01-04 23:34:14 +0000513 case tok::pp_define:
514 parsePPDefine();
Alexander Kornienkof2e02122013-05-24 18:24:24 +0000515 return;
516 case tok::pp_if:
Manuel Klimek71814b42013-10-11 21:25:45 +0000517 parsePPIf(/*IfDef=*/false);
Alexander Kornienkof2e02122013-05-24 18:24:24 +0000518 break;
519 case tok::pp_ifdef:
520 case tok::pp_ifndef:
Manuel Klimek71814b42013-10-11 21:25:45 +0000521 parsePPIf(/*IfDef=*/true);
Alexander Kornienkof2e02122013-05-24 18:24:24 +0000522 break;
523 case tok::pp_else:
524 parsePPElse();
525 break;
526 case tok::pp_elif:
527 parsePPElIf();
528 break;
529 case tok::pp_endif:
530 parsePPEndIf();
Manuel Klimek1abf7892013-01-04 23:34:14 +0000531 break;
532 default:
533 parsePPUnknown();
534 break;
535 }
536}
537
Manuel Klimek68b03042014-04-14 09:14:11 +0000538void UnwrappedLineParser::conditionalCompilationCondition(bool Unreachable) {
539 if (Unreachable || (!PPStack.empty() && PPStack.back() == PP_Unreachable))
Alexander Kornienkof2e02122013-05-24 18:24:24 +0000540 PPStack.push_back(PP_Unreachable);
541 else
542 PPStack.push_back(PP_Conditional);
543}
544
Manuel Klimek68b03042014-04-14 09:14:11 +0000545void UnwrappedLineParser::conditionalCompilationStart(bool Unreachable) {
Manuel Klimek71814b42013-10-11 21:25:45 +0000546 ++PPBranchLevel;
547 assert(PPBranchLevel >= 0 && PPBranchLevel <= (int)PPLevelBranchIndex.size());
548 if (PPBranchLevel == (int)PPLevelBranchIndex.size()) {
549 PPLevelBranchIndex.push_back(0);
550 PPLevelBranchCount.push_back(0);
551 }
552 PPChainBranchIndex.push(0);
Manuel Klimek68b03042014-04-14 09:14:11 +0000553 bool Skip = PPLevelBranchIndex[PPBranchLevel] > 0;
554 conditionalCompilationCondition(Unreachable || Skip);
Alexander Kornienkof2e02122013-05-24 18:24:24 +0000555}
556
Manuel Klimek68b03042014-04-14 09:14:11 +0000557void UnwrappedLineParser::conditionalCompilationAlternative() {
Alexander Kornienkof2e02122013-05-24 18:24:24 +0000558 if (!PPStack.empty())
559 PPStack.pop_back();
Manuel Klimek71814b42013-10-11 21:25:45 +0000560 assert(PPBranchLevel < (int)PPLevelBranchIndex.size());
561 if (!PPChainBranchIndex.empty())
562 ++PPChainBranchIndex.top();
Manuel Klimek68b03042014-04-14 09:14:11 +0000563 conditionalCompilationCondition(
564 PPBranchLevel >= 0 && !PPChainBranchIndex.empty() &&
565 PPLevelBranchIndex[PPBranchLevel] != PPChainBranchIndex.top());
Alexander Kornienkof2e02122013-05-24 18:24:24 +0000566}
567
Manuel Klimek68b03042014-04-14 09:14:11 +0000568void UnwrappedLineParser::conditionalCompilationEnd() {
Manuel Klimek71814b42013-10-11 21:25:45 +0000569 assert(PPBranchLevel < (int)PPLevelBranchIndex.size());
570 if (PPBranchLevel >= 0 && !PPChainBranchIndex.empty()) {
571 if (PPChainBranchIndex.top() + 1 > PPLevelBranchCount[PPBranchLevel]) {
Manuel Klimek71814b42013-10-11 21:25:45 +0000572 PPLevelBranchCount[PPBranchLevel] = PPChainBranchIndex.top() + 1;
573 }
574 }
Manuel Klimek14bd9172014-01-29 08:49:02 +0000575 // Guard against #endif's without #if.
576 if (PPBranchLevel > 0)
577 --PPBranchLevel;
Manuel Klimek71814b42013-10-11 21:25:45 +0000578 if (!PPChainBranchIndex.empty())
579 PPChainBranchIndex.pop();
Alexander Kornienkof2e02122013-05-24 18:24:24 +0000580 if (!PPStack.empty())
581 PPStack.pop_back();
Manuel Klimek68b03042014-04-14 09:14:11 +0000582}
583
584void UnwrappedLineParser::parsePPIf(bool IfDef) {
585 nextToken();
586 bool IsLiteralFalse = (FormatTok->Tok.isLiteral() &&
Daniel Jasper9d22bcc2015-01-19 10:51:05 +0000587 FormatTok->Tok.getLiteralData() != nullptr &&
Manuel Klimek68b03042014-04-14 09:14:11 +0000588 StringRef(FormatTok->Tok.getLiteralData(),
589 FormatTok->Tok.getLength()) == "0") ||
590 FormatTok->Tok.is(tok::kw_false);
591 conditionalCompilationStart(!IfDef && IsLiteralFalse);
592 parsePPUnknown();
593}
594
595void UnwrappedLineParser::parsePPElse() {
596 conditionalCompilationAlternative();
597 parsePPUnknown();
598}
599
600void UnwrappedLineParser::parsePPElIf() { parsePPElse(); }
601
602void UnwrappedLineParser::parsePPEndIf() {
603 conditionalCompilationEnd();
Alexander Kornienkof2e02122013-05-24 18:24:24 +0000604 parsePPUnknown();
605}
606
Manuel Klimek1abf7892013-01-04 23:34:14 +0000607void UnwrappedLineParser::parsePPDefine() {
608 nextToken();
609
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000610 if (FormatTok->Tok.getKind() != tok::identifier) {
Manuel Klimek1abf7892013-01-04 23:34:14 +0000611 parsePPUnknown();
612 return;
613 }
614 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000615 if (FormatTok->Tok.getKind() == tok::l_paren &&
616 FormatTok->WhitespaceRange.getBegin() ==
617 FormatTok->WhitespaceRange.getEnd()) {
Manuel Klimek1abf7892013-01-04 23:34:14 +0000618 parseParens();
619 }
620 addUnwrappedLine();
Manuel Klimek52b15152013-01-09 15:25:02 +0000621 Line->Level = 1;
Manuel Klimek1b896292013-01-07 09:34:28 +0000622
623 // Errors during a preprocessor directive can only affect the layout of the
624 // preprocessor directive, and thus we ignore them. An alternative approach
625 // would be to use the same approach we use on the file level (no
626 // re-indentation if there was a structural error) within the macro
627 // definition.
Manuel Klimek1abf7892013-01-04 23:34:14 +0000628 parseFile();
629}
630
631void UnwrappedLineParser::parsePPUnknown() {
Manuel Klimeka71e5d82013-01-02 16:30:12 +0000632 do {
Manuel Klimeka71e5d82013-01-02 16:30:12 +0000633 nextToken();
634 } while (!eof());
635 addUnwrappedLine();
Daniel Jasperf7935112012-12-03 18:12:45 +0000636}
637
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +0000638// Here we blacklist certain tokens that are not usually the first token in an
639// unwrapped line. This is used in attempt to distinguish macro calls without
640// trailing semicolons from other constructs split to several lines.
Benjamin Kramer8407df72015-03-09 16:47:52 +0000641static bool tokenCanStartNewLine(const clang::Token &Tok) {
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +0000642 // Semicolon can be a null-statement, l_square can be a start of a macro or
643 // a C++11 attribute, but this doesn't seem to be common.
644 return Tok.isNot(tok::semi) && Tok.isNot(tok::l_brace) &&
645 Tok.isNot(tok::l_square) &&
646 // Tokens that can only be used as binary operators and a part of
647 // overloaded operator names.
648 Tok.isNot(tok::period) && Tok.isNot(tok::periodstar) &&
649 Tok.isNot(tok::arrow) && Tok.isNot(tok::arrowstar) &&
650 Tok.isNot(tok::less) && Tok.isNot(tok::greater) &&
651 Tok.isNot(tok::slash) && Tok.isNot(tok::percent) &&
652 Tok.isNot(tok::lessless) && Tok.isNot(tok::greatergreater) &&
653 Tok.isNot(tok::equal) && Tok.isNot(tok::plusequal) &&
654 Tok.isNot(tok::minusequal) && Tok.isNot(tok::starequal) &&
655 Tok.isNot(tok::slashequal) && Tok.isNot(tok::percentequal) &&
656 Tok.isNot(tok::ampequal) && Tok.isNot(tok::pipeequal) &&
657 Tok.isNot(tok::caretequal) && Tok.isNot(tok::greatergreaterequal) &&
658 Tok.isNot(tok::lesslessequal) &&
659 // Colon is used in labels, base class lists, initializer lists,
660 // range-based for loops, ternary operator, but should never be the
661 // first token in an unwrapped line.
Daniel Jasper5ebb2f32014-05-21 13:08:17 +0000662 Tok.isNot(tok::colon) &&
663 // 'noexcept' is a trailing annotation.
664 Tok.isNot(tok::kw_noexcept);
Alexander Kornienkoa04e5e22013-04-09 16:15:19 +0000665}
666
Martin Probst533965c2016-04-19 18:19:06 +0000667static bool mustBeJSIdent(const AdditionalKeywords &Keywords,
668 const FormatToken *FormatTok) {
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000669 // FIXME: This returns true for C/C++ keywords like 'struct'.
670 return FormatTok->is(tok::identifier) &&
671 (FormatTok->Tok.getIdentifierInfo() == nullptr ||
Martin Probst3dbbefa2016-11-10 16:21:02 +0000672 !FormatTok->isOneOf(
673 Keywords.kw_in, Keywords.kw_of, Keywords.kw_as, Keywords.kw_async,
674 Keywords.kw_await, Keywords.kw_yield, Keywords.kw_finally,
675 Keywords.kw_function, Keywords.kw_import, Keywords.kw_is,
676 Keywords.kw_let, Keywords.kw_var, tok::kw_const,
677 Keywords.kw_abstract, Keywords.kw_extends, Keywords.kw_implements,
678 Keywords.kw_instanceof, Keywords.kw_interface,
679 Keywords.kw_throws));
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000680}
681
Martin Probst533965c2016-04-19 18:19:06 +0000682static bool mustBeJSIdentOrValue(const AdditionalKeywords &Keywords,
683 const FormatToken *FormatTok) {
Martin Probstb9316ff2016-09-18 17:21:52 +0000684 return FormatTok->Tok.isLiteral() ||
685 FormatTok->isOneOf(tok::kw_true, tok::kw_false) ||
686 mustBeJSIdent(Keywords, FormatTok);
Martin Probst533965c2016-04-19 18:19:06 +0000687}
688
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000689// isJSDeclOrStmt returns true if |FormatTok| starts a declaration or statement
690// when encountered after a value (see mustBeJSIdentOrValue).
691static bool isJSDeclOrStmt(const AdditionalKeywords &Keywords,
692 const FormatToken *FormatTok) {
693 return FormatTok->isOneOf(
Martin Probst5f8445b2016-04-24 22:05:09 +0000694 tok::kw_return, Keywords.kw_yield,
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000695 // conditionals
696 tok::kw_if, tok::kw_else,
697 // loops
698 tok::kw_for, tok::kw_while, tok::kw_do, tok::kw_continue, tok::kw_break,
699 // switch/case
700 tok::kw_switch, tok::kw_case,
701 // exceptions
702 tok::kw_throw, tok::kw_try, tok::kw_catch, Keywords.kw_finally,
703 // declaration
704 tok::kw_const, tok::kw_class, Keywords.kw_var, Keywords.kw_let,
Martin Probst5f8445b2016-04-24 22:05:09 +0000705 Keywords.kw_async, Keywords.kw_function,
706 // import/export
707 Keywords.kw_import, tok::kw_export);
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000708}
709
710// readTokenWithJavaScriptASI reads the next token and terminates the current
711// line if JavaScript Automatic Semicolon Insertion must
712// happen between the current token and the next token.
713//
714// This method is conservative - it cannot cover all edge cases of JavaScript,
715// but only aims to correctly handle certain well known cases. It *must not*
716// return true in speculative cases.
717void UnwrappedLineParser::readTokenWithJavaScriptASI() {
718 FormatToken *Previous = FormatTok;
719 readToken();
720 FormatToken *Next = FormatTok;
721
722 bool IsOnSameLine =
723 CommentsBeforeNextToken.empty()
724 ? Next->NewlinesBefore == 0
725 : CommentsBeforeNextToken.front()->NewlinesBefore == 0;
726 if (IsOnSameLine)
727 return;
728
729 bool PreviousMustBeValue = mustBeJSIdentOrValue(Keywords, Previous);
Martin Probst717f6dc2016-10-21 05:11:38 +0000730 bool PreviousStartsTemplateExpr =
731 Previous->is(TT_TemplateString) && Previous->TokenText.endswith("${");
Martin Probstbbffeac2016-04-11 07:35:57 +0000732 if (PreviousMustBeValue && Line && Line->Tokens.size() > 1) {
733 // If the token before the previous one is an '@', the previous token is an
734 // annotation and can precede another identifier/value.
Benjamin Kramer5ffc24e2016-04-11 12:19:19 +0000735 const FormatToken *PrePrevious = std::prev(Line->Tokens.end(), 2)->Tok;
Martin Probstbbffeac2016-04-11 07:35:57 +0000736 if (PrePrevious->is(tok::at))
737 return;
738 }
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000739 if (Next->is(tok::exclaim) && PreviousMustBeValue)
Martin Probstd40bca42017-01-09 08:56:36 +0000740 return addUnwrappedLine();
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000741 bool NextMustBeValue = mustBeJSIdentOrValue(Keywords, Next);
Martin Probst717f6dc2016-10-21 05:11:38 +0000742 bool NextEndsTemplateExpr =
743 Next->is(TT_TemplateString) && Next->TokenText.startswith("}");
744 if (NextMustBeValue && !NextEndsTemplateExpr && !PreviousStartsTemplateExpr &&
745 (PreviousMustBeValue ||
746 Previous->isOneOf(tok::r_square, tok::r_paren, tok::plusplus,
747 tok::minusminus)))
Martin Probstd40bca42017-01-09 08:56:36 +0000748 return addUnwrappedLine();
749 if ((PreviousMustBeValue || Previous->is(tok::r_brace)) &&
750 isJSDeclOrStmt(Keywords, Next))
751 return addUnwrappedLine();
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000752}
753
Manuel Klimek6b9eeba2013-01-07 14:56:16 +0000754void UnwrappedLineParser::parseStructuralElement() {
Daniel Jasper498f5582015-12-25 08:53:31 +0000755 assert(!FormatTok->is(tok::l_brace));
756 if (Style.Language == FormatStyle::LK_TableGen &&
757 FormatTok->is(tok::pp_include)) {
758 nextToken();
759 if (FormatTok->is(tok::string_literal))
760 nextToken();
761 addUnwrappedLine();
762 return;
763 }
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000764 switch (FormatTok->Tok.getKind()) {
Nico Weber04e9f1a2013-01-07 19:05:19 +0000765 case tok::at:
766 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000767 if (FormatTok->Tok.is(tok::l_brace)) {
Nico Weber372d8dc2013-02-10 20:35:35 +0000768 parseBracedList();
769 break;
770 }
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000771 switch (FormatTok->Tok.getObjCKeywordID()) {
Nico Weber04e9f1a2013-01-07 19:05:19 +0000772 case tok::objc_public:
773 case tok::objc_protected:
774 case tok::objc_package:
775 case tok::objc_private:
776 return parseAccessSpecifier();
Nico Weber7eecf4b2013-01-09 20:25:35 +0000777 case tok::objc_interface:
Nico Weber2ce0ac52013-01-09 23:25:37 +0000778 case tok::objc_implementation:
779 return parseObjCInterfaceOrImplementation();
Nico Weber8696a8d2013-01-09 21:15:03 +0000780 case tok::objc_protocol:
781 return parseObjCProtocol();
Nico Weberd8ffe752013-01-09 21:42:32 +0000782 case tok::objc_end:
783 return; // Handled by the caller.
Nico Weber51306d22013-01-10 00:25:19 +0000784 case tok::objc_optional:
785 case tok::objc_required:
786 nextToken();
787 addUnwrappedLine();
788 return;
Nico Weber45c48122015-06-28 01:06:16 +0000789 case tok::objc_autoreleasepool:
790 nextToken();
791 if (FormatTok->Tok.is(tok::l_brace)) {
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000792 if (Style.BraceWrapping.AfterObjCDeclaration)
Nico Weber45c48122015-06-28 01:06:16 +0000793 addUnwrappedLine();
794 parseBlock(/*MustBeDeclaration=*/false);
795 }
796 addUnwrappedLine();
797 return;
Nico Weber33381f52015-02-07 01:57:32 +0000798 case tok::objc_try:
799 // This branch isn't strictly necessary (the kw_try case below would
800 // do this too after the tok::at is parsed above). But be explicit.
801 parseTryCatch();
802 return;
Nico Weber04e9f1a2013-01-07 19:05:19 +0000803 default:
804 break;
805 }
806 break;
Daniel Jasper8f463652014-08-26 23:15:12 +0000807 case tok::kw_asm:
Daniel Jasper8f463652014-08-26 23:15:12 +0000808 nextToken();
809 if (FormatTok->is(tok::l_brace)) {
Daniel Jasperc6366072015-05-10 08:42:04 +0000810 FormatTok->Type = TT_InlineASMBrace;
Daniel Jasper2337f282015-01-12 10:14:56 +0000811 nextToken();
Daniel Jasper4429f142014-08-27 17:16:46 +0000812 while (FormatTok && FormatTok->isNot(tok::eof)) {
Daniel Jasper8f463652014-08-26 23:15:12 +0000813 if (FormatTok->is(tok::r_brace)) {
Daniel Jasperc6366072015-05-10 08:42:04 +0000814 FormatTok->Type = TT_InlineASMBrace;
Daniel Jasper8f463652014-08-26 23:15:12 +0000815 nextToken();
Daniel Jasper790d4f92015-05-11 11:59:46 +0000816 addUnwrappedLine();
Daniel Jasper8f463652014-08-26 23:15:12 +0000817 break;
818 }
Daniel Jasper2337f282015-01-12 10:14:56 +0000819 FormatTok->Finalized = true;
Daniel Jasper8f463652014-08-26 23:15:12 +0000820 nextToken();
821 }
822 }
823 break;
Alexander Kornienko578fdd82012-12-06 18:03:27 +0000824 case tok::kw_namespace:
825 parseNamespace();
826 return;
Dmitri Gribenko58d64e22012-12-30 21:27:25 +0000827 case tok::kw_inline:
828 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000829 if (FormatTok->Tok.is(tok::kw_namespace)) {
Dmitri Gribenko58d64e22012-12-30 21:27:25 +0000830 parseNamespace();
831 return;
832 }
833 break;
Alexander Kornienkob7076a22012-12-04 14:46:19 +0000834 case tok::kw_public:
835 case tok::kw_protected:
836 case tok::kw_private:
Daniel Jasper83709082015-02-18 17:14:05 +0000837 if (Style.Language == FormatStyle::LK_Java ||
838 Style.Language == FormatStyle::LK_JavaScript)
Daniel Jasperc58c70e2014-09-15 11:21:46 +0000839 nextToken();
840 else
841 parseAccessSpecifier();
Daniel Jasperf7935112012-12-03 18:12:45 +0000842 return;
Alexander Kornienkob7076a22012-12-04 14:46:19 +0000843 case tok::kw_if:
844 parseIfThenElse();
Daniel Jasperf7935112012-12-03 18:12:45 +0000845 return;
Alexander Kornienko37d6c942012-12-05 15:06:06 +0000846 case tok::kw_for:
847 case tok::kw_while:
848 parseForOrWhileLoop();
849 return;
Alexander Kornienkob7076a22012-12-04 14:46:19 +0000850 case tok::kw_do:
851 parseDoWhile();
852 return;
853 case tok::kw_switch:
854 parseSwitch();
855 return;
856 case tok::kw_default:
857 nextToken();
858 parseLabel();
859 return;
860 case tok::kw_case:
861 parseCaseLabel();
862 return;
Daniel Jasper04a71a42014-05-08 11:58:24 +0000863 case tok::kw_try:
Nico Weberfac23712015-02-04 15:26:27 +0000864 case tok::kw___try:
Daniel Jasper04a71a42014-05-08 11:58:24 +0000865 parseTryCatch();
866 return;
Manuel Klimekae610d12013-01-21 14:32:05 +0000867 case tok::kw_extern:
868 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000869 if (FormatTok->Tok.is(tok::string_literal)) {
Manuel Klimekae610d12013-01-21 14:32:05 +0000870 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000871 if (FormatTok->Tok.is(tok::l_brace)) {
Daniel Jasper65ee3472013-07-31 23:16:02 +0000872 parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/false);
Manuel Klimekae610d12013-01-21 14:32:05 +0000873 addUnwrappedLine();
874 return;
875 }
876 }
Daniel Jaspere1e43192014-04-01 12:55:11 +0000877 break;
Daniel Jasperfca735c2015-02-19 16:14:18 +0000878 case tok::kw_export:
879 if (Style.Language == FormatStyle::LK_JavaScript) {
880 parseJavaScriptEs6ImportExport();
881 return;
882 }
883 break;
Daniel Jaspere1e43192014-04-01 12:55:11 +0000884 case tok::identifier:
Daniel Jasper66cb8c52015-05-04 09:22:29 +0000885 if (FormatTok->is(TT_ForEachMacro)) {
Daniel Jaspere1e43192014-04-01 12:55:11 +0000886 parseForOrWhileLoop();
887 return;
888 }
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +0000889 if (FormatTok->is(TT_MacroBlockBegin)) {
890 parseBlock(/*MustBeDeclaration=*/false, /*AddLevel=*/true,
891 /*MunchSemi=*/false);
892 return;
893 }
Daniel Jasper3d5a7d62016-06-20 18:20:38 +0000894 if (FormatTok->is(Keywords.kw_import)) {
895 if (Style.Language == FormatStyle::LK_JavaScript) {
896 parseJavaScriptEs6ImportExport();
897 return;
898 }
899 if (Style.Language == FormatStyle::LK_Proto) {
900 nextToken();
Daniel Jasper8b61d142016-06-20 20:39:53 +0000901 if (FormatTok->is(tok::kw_public))
902 nextToken();
Daniel Jasper3d5a7d62016-06-20 18:20:38 +0000903 if (!FormatTok->is(tok::string_literal))
904 return;
905 nextToken();
906 if (FormatTok->is(tok::semi))
907 nextToken();
908 addUnwrappedLine();
909 return;
910 }
Daniel Jasper354aa512015-02-19 16:07:32 +0000911 }
Daniel Jaspera00de632015-12-01 12:05:04 +0000912 if (FormatTok->isOneOf(Keywords.kw_signals, Keywords.kw_qsignals,
913 Keywords.kw_slots, Keywords.kw_qslots)) {
Daniel Jasperde0d1f32015-04-24 07:50:34 +0000914 nextToken();
915 if (FormatTok->is(tok::colon)) {
916 nextToken();
917 addUnwrappedLine();
Daniel Jasper31343832016-07-27 10:13:24 +0000918 return;
Daniel Jasperde0d1f32015-04-24 07:50:34 +0000919 }
Daniel Jasper53395402015-04-07 15:04:40 +0000920 }
Manuel Klimekae610d12013-01-21 14:32:05 +0000921 // In all other cases, parse the declaration.
922 break;
Alexander Kornienkob7076a22012-12-04 14:46:19 +0000923 default:
924 break;
Daniel Jasperf7935112012-12-03 18:12:45 +0000925 }
Daniel Jasperf7935112012-12-03 18:12:45 +0000926 do {
Daniel Jaspera7900ad2016-05-08 18:12:22 +0000927 const FormatToken *Previous = getPreviousToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000928 switch (FormatTok->Tok.getKind()) {
Nico Weber372d8dc2013-02-10 20:35:35 +0000929 case tok::at:
930 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +0000931 if (FormatTok->Tok.is(tok::l_brace))
Nico Weber372d8dc2013-02-10 20:35:35 +0000932 parseBracedList();
933 break;
Alexander Kornienkob7076a22012-12-04 14:46:19 +0000934 case tok::kw_enum:
Daniel Jaspera7900ad2016-05-08 18:12:22 +0000935 // Ignore if this is part of "template <enum ...".
936 if (Previous && Previous->is(tok::less)) {
937 nextToken();
938 break;
939 }
940
Daniel Jasper90cf3802015-06-17 09:44:02 +0000941 // parseEnum falls through and does not yet add an unwrapped line as an
942 // enum definition can start a structural element.
Daniel Jasper6f5a1932015-12-29 08:54:23 +0000943 if (!parseEnum())
944 break;
Daniel Jasperc6dd2732015-07-16 14:25:43 +0000945 // This only applies for C++.
946 if (Style.Language != FormatStyle::LK_Cpp) {
Daniel Jasper90cf3802015-06-17 09:44:02 +0000947 addUnwrappedLine();
948 return;
949 }
Manuel Klimek2cec0192013-01-21 19:17:52 +0000950 break;
Daniel Jaspera88f80a2014-01-30 14:38:37 +0000951 case tok::kw_typedef:
952 nextToken();
Daniel Jasper31f6c542014-12-05 10:42:21 +0000953 if (FormatTok->isOneOf(Keywords.kw_NS_ENUM, Keywords.kw_NS_OPTIONS,
954 Keywords.kw_CF_ENUM, Keywords.kw_CF_OPTIONS))
Daniel Jaspera88f80a2014-01-30 14:38:37 +0000955 parseEnum();
956 break;
Alexander Kornienko1231e062013-01-16 11:43:46 +0000957 case tok::kw_struct:
958 case tok::kw_union:
Manuel Klimek28cacc72013-01-07 18:10:23 +0000959 case tok::kw_class:
Daniel Jasper910807d2015-06-12 04:52:02 +0000960 // parseRecord falls through and does not yet add an unwrapped line as a
961 // record declaration or definition can start a structural element.
Manuel Klimeke01bab52013-01-15 13:38:33 +0000962 parseRecord();
Daniel Jasper910807d2015-06-12 04:52:02 +0000963 // This does not apply for Java and JavaScript.
964 if (Style.Language == FormatStyle::LK_Java ||
965 Style.Language == FormatStyle::LK_JavaScript) {
Daniel Jasperd5ec65b2016-01-08 07:06:07 +0000966 if (FormatTok->is(tok::semi))
967 nextToken();
Daniel Jasper910807d2015-06-12 04:52:02 +0000968 addUnwrappedLine();
969 return;
970 }
Manuel Klimeke01bab52013-01-15 13:38:33 +0000971 break;
Daniel Jaspere5d74862014-11-26 08:17:08 +0000972 case tok::period:
973 nextToken();
974 // In Java, classes have an implicit static member "class".
975 if (Style.Language == FormatStyle::LK_Java && FormatTok &&
976 FormatTok->is(tok::kw_class))
977 nextToken();
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000978 if (Style.Language == FormatStyle::LK_JavaScript && FormatTok &&
979 FormatTok->Tok.getIdentifierInfo())
980 // JavaScript only has pseudo keywords, all keywords are allowed to
981 // appear in "IdentifierName" positions. See http://es5.github.io/#x7.6
982 nextToken();
Daniel Jaspere5d74862014-11-26 08:17:08 +0000983 break;
Daniel Jasperf7935112012-12-03 18:12:45 +0000984 case tok::semi:
985 nextToken();
986 addUnwrappedLine();
987 return;
Alexander Kornienko1231e062013-01-16 11:43:46 +0000988 case tok::r_brace:
989 addUnwrappedLine();
990 return;
Daniel Jasperf7935112012-12-03 18:12:45 +0000991 case tok::l_paren:
992 parseParens();
993 break;
Daniel Jasper5af04a42015-10-07 03:43:10 +0000994 case tok::kw_operator:
995 nextToken();
996 if (FormatTok->isBinaryOperator())
997 nextToken();
998 break;
Manuel Klimek516e0542013-09-04 13:25:30 +0000999 case tok::caret:
1000 nextToken();
Daniel Jasper395193c2014-03-28 07:48:59 +00001001 if (FormatTok->Tok.isAnyIdentifier() ||
1002 FormatTok->isSimpleTypeSpecifier())
1003 nextToken();
1004 if (FormatTok->is(tok::l_paren))
1005 parseParens();
1006 if (FormatTok->is(tok::l_brace))
Manuel Klimek516e0542013-09-04 13:25:30 +00001007 parseChildBlock();
Manuel Klimek516e0542013-09-04 13:25:30 +00001008 break;
Daniel Jasperf7935112012-12-03 18:12:45 +00001009 case tok::l_brace:
Manuel Klimekab419912013-05-23 09:41:43 +00001010 if (!tryToParseBracedList()) {
1011 // A block outside of parentheses must be the last part of a
1012 // structural element.
1013 // FIXME: Figure out cases where this is not true, and add projections
1014 // for them (the one we know is missing are lambdas).
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00001015 if (Style.BraceWrapping.AfterFunction)
Manuel Klimekab419912013-05-23 09:41:43 +00001016 addUnwrappedLine();
Alexander Kornienko3cfa9732013-11-20 16:33:05 +00001017 FormatTok->Type = TT_FunctionLBrace;
Nico Weber9096fc02013-06-26 00:30:14 +00001018 parseBlock(/*MustBeDeclaration=*/false);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00001019 addUnwrappedLine();
Manuel Klimekab419912013-05-23 09:41:43 +00001020 return;
1021 }
1022 // Otherwise this was a braced init list, and the structural
1023 // element continues.
1024 break;
Daniel Jasper04a71a42014-05-08 11:58:24 +00001025 case tok::kw_try:
1026 // We arrive here when parsing function-try blocks.
1027 parseTryCatch();
1028 return;
Daniel Jasper40e19212013-05-29 13:16:10 +00001029 case tok::identifier: {
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +00001030 if (FormatTok->is(TT_MacroBlockEnd)) {
1031 addUnwrappedLine();
1032 return;
1033 }
1034
Daniel Jasperad9eb0d2014-06-30 13:24:54 +00001035 // Parse function literal unless 'function' is the first token in a line
1036 // in which case this should be treated as a free-standing function.
Daniel Jasper9326f912015-05-05 08:40:32 +00001037 if (Style.Language == FormatStyle::LK_JavaScript &&
Martin Probst409697e2016-05-29 14:41:07 +00001038 (FormatTok->is(Keywords.kw_function) ||
1039 FormatTok->startsSequence(Keywords.kw_async,
1040 Keywords.kw_function)) &&
Martin Probst5f8445b2016-04-24 22:05:09 +00001041 Line->Tokens.size() > 0) {
Daniel Jasper069e5f42014-05-20 11:14:57 +00001042 tryToParseJSFunction();
1043 break;
1044 }
Daniel Jasper9326f912015-05-05 08:40:32 +00001045 if ((Style.Language == FormatStyle::LK_JavaScript ||
1046 Style.Language == FormatStyle::LK_Java) &&
1047 FormatTok->is(Keywords.kw_interface)) {
Martin Probst1e8261e2016-04-19 18:18:59 +00001048 if (Style.Language == FormatStyle::LK_JavaScript) {
1049 // In JavaScript/TypeScript, "interface" can be used as a standalone
1050 // identifier, e.g. in `var interface = 1;`. If "interface" is
1051 // followed by another identifier, it is very like to be an actual
1052 // interface declaration.
1053 unsigned StoredPosition = Tokens->getPosition();
1054 FormatToken *Next = Tokens->getNextToken();
1055 FormatTok = Tokens->setPosition(StoredPosition);
Martin Probst533965c2016-04-19 18:19:06 +00001056 if (Next && !mustBeJSIdent(Keywords, Next)) {
Martin Probst1e8261e2016-04-19 18:18:59 +00001057 nextToken();
1058 break;
1059 }
1060 }
Daniel Jasper9326f912015-05-05 08:40:32 +00001061 parseRecord();
Daniel Jasper259188b2015-06-12 04:56:34 +00001062 addUnwrappedLine();
Daniel Jasper5c235c02015-07-06 14:26:04 +00001063 return;
Daniel Jasper9326f912015-05-05 08:40:32 +00001064 }
1065
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001066 // See if the following token should start a new unwrapped line.
Daniel Jasper9326f912015-05-05 08:40:32 +00001067 StringRef Text = FormatTok->TokenText;
Daniel Jasperf7935112012-12-03 18:12:45 +00001068 nextToken();
Daniel Jasper83709082015-02-18 17:14:05 +00001069 if (Line->Tokens.size() == 1 &&
1070 // JS doesn't have macros, and within classes colons indicate fields,
1071 // not labels.
Daniel Jasper676e5162015-04-07 14:36:33 +00001072 Style.Language != FormatStyle::LK_JavaScript) {
1073 if (FormatTok->Tok.is(tok::colon) && !Line->MustBeDeclaration) {
Daniel Jasper40609472016-04-06 15:02:46 +00001074 Line->Tokens.begin()->Tok->MustBreakBefore = true;
Alexander Kornienkode644272013-04-08 22:16:06 +00001075 parseLabel();
1076 return;
1077 }
Daniel Jasper680b09b2014-11-05 10:48:04 +00001078 // Recognize function-like macro usages without trailing semicolon as
Daniel Jasper83709082015-02-18 17:14:05 +00001079 // well as free-standing macros like Q_OBJECT.
Daniel Jasper680b09b2014-11-05 10:48:04 +00001080 bool FunctionLike = FormatTok->is(tok::l_paren);
1081 if (FunctionLike)
Alexander Kornienkode644272013-04-08 22:16:06 +00001082 parseParens();
Daniel Jaspere60cba12015-05-13 11:35:53 +00001083
1084 bool FollowedByNewline =
1085 CommentsBeforeNextToken.empty()
1086 ? FormatTok->NewlinesBefore > 0
1087 : CommentsBeforeNextToken.front()->NewlinesBefore > 0;
1088
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00001089 if (FollowedByNewline && (Text.size() >= 5 || FunctionLike) &&
Daniel Jasper680b09b2014-11-05 10:48:04 +00001090 tokenCanStartNewLine(FormatTok->Tok) && Text == Text.upper()) {
Daniel Jasper40e19212013-05-29 13:16:10 +00001091 addUnwrappedLine();
Daniel Jasper41a0f782013-05-29 14:09:17 +00001092 return;
Alexander Kornienkode644272013-04-08 22:16:06 +00001093 }
Daniel Jasperf7935112012-12-03 18:12:45 +00001094 }
1095 break;
Daniel Jasper40e19212013-05-29 13:16:10 +00001096 }
Daniel Jaspere25509f2012-12-17 11:29:41 +00001097 case tok::equal:
Manuel Klimek79e06082015-05-21 12:23:34 +00001098 // Fat arrows (=>) have tok::TokenKind tok::equal but TokenType
1099 // TT_JsFatArrow. The always start an expression or a child block if
1100 // followed by a curly.
1101 if (FormatTok->is(TT_JsFatArrow)) {
1102 nextToken();
Daniel Jasperbe520bd2015-05-31 08:51:54 +00001103 if (FormatTok->is(tok::l_brace))
Manuel Klimek79e06082015-05-21 12:23:34 +00001104 parseChildBlock();
Manuel Klimek79e06082015-05-21 12:23:34 +00001105 break;
1106 }
1107
Daniel Jaspere25509f2012-12-17 11:29:41 +00001108 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001109 if (FormatTok->Tok.is(tok::l_brace)) {
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00001110 parseBracedList();
1111 }
Daniel Jaspere25509f2012-12-17 11:29:41 +00001112 break;
Manuel Klimekffdeb592013-09-03 15:10:01 +00001113 case tok::l_square:
Daniel Jasperb88b25f2013-12-23 07:29:06 +00001114 parseSquare();
Manuel Klimekffdeb592013-09-03 15:10:01 +00001115 break;
Daniel Jasper6acf5132015-03-12 14:44:29 +00001116 case tok::kw_new:
1117 parseNew();
1118 break;
Alexander Kornienkob7076a22012-12-04 14:46:19 +00001119 default:
1120 nextToken();
1121 break;
Daniel Jasperf7935112012-12-03 18:12:45 +00001122 }
1123 } while (!eof());
1124}
1125
Daniel Jasperb88b25f2013-12-23 07:29:06 +00001126bool UnwrappedLineParser::tryToParseLambda() {
Daniel Jasper1feab0f2015-06-02 15:31:37 +00001127 if (Style.Language != FormatStyle::LK_Cpp) {
1128 nextToken();
1129 return false;
1130 }
Daniel Jasperb9a49902016-01-09 15:56:28 +00001131 const FormatToken* Previous = getPreviousToken();
1132 if (Previous &&
1133 (Previous->isOneOf(tok::identifier, tok::kw_operator, tok::kw_new,
1134 tok::kw_delete) ||
1135 Previous->closesScope() || Previous->isSimpleTypeSpecifier())) {
Daniel Jasperbf02b2c12013-09-05 11:49:39 +00001136 nextToken();
Daniel Jasperb88b25f2013-12-23 07:29:06 +00001137 return false;
Daniel Jasperbf02b2c12013-09-05 11:49:39 +00001138 }
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00001139 assert(FormatTok->is(tok::l_square));
1140 FormatToken &LSquare = *FormatTok;
Daniel Jasper9a8d48b2013-09-05 10:04:31 +00001141 if (!tryToParseLambdaIntroducer())
Daniel Jasperb88b25f2013-12-23 07:29:06 +00001142 return false;
Manuel Klimekffdeb592013-09-03 15:10:01 +00001143
Alexander Kornienkoc2ee9cf2014-03-13 13:59:48 +00001144 while (FormatTok->isNot(tok::l_brace)) {
Daniel Jaspercb51cf42014-01-16 09:11:55 +00001145 if (FormatTok->isSimpleTypeSpecifier()) {
1146 nextToken();
1147 continue;
1148 }
Manuel Klimekffdeb592013-09-03 15:10:01 +00001149 switch (FormatTok->Tok.getKind()) {
Daniel Jasper9a8d48b2013-09-05 10:04:31 +00001150 case tok::l_brace:
1151 break;
1152 case tok::l_paren:
1153 parseParens();
1154 break;
Daniel Jasperbcb55ee2014-11-21 14:08:38 +00001155 case tok::amp:
1156 case tok::star:
1157 case tok::kw_const:
Daniel Jasper3431b752014-12-08 13:22:37 +00001158 case tok::comma:
Daniel Jaspercb51cf42014-01-16 09:11:55 +00001159 case tok::less:
1160 case tok::greater:
Daniel Jasper9a8d48b2013-09-05 10:04:31 +00001161 case tok::identifier:
Daniel Jasper5eaa0092015-08-13 13:37:08 +00001162 case tok::numeric_constant:
Daniel Jasper1067ab02014-02-11 10:16:55 +00001163 case tok::coloncolon:
Daniel Jasper9a8d48b2013-09-05 10:04:31 +00001164 case tok::kw_mutable:
Daniel Jasper81a20782014-03-10 10:02:02 +00001165 nextToken();
1166 break;
Daniel Jaspercb51cf42014-01-16 09:11:55 +00001167 case tok::arrow:
Daniel Jasper6f2b88a2015-06-05 13:18:09 +00001168 FormatTok->Type = TT_LambdaArrow;
Daniel Jasper9a8d48b2013-09-05 10:04:31 +00001169 nextToken();
1170 break;
1171 default:
Daniel Jasperb88b25f2013-12-23 07:29:06 +00001172 return true;
Manuel Klimekffdeb592013-09-03 15:10:01 +00001173 }
1174 }
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00001175 LSquare.Type = TT_LambdaLSquare;
Manuel Klimek516e0542013-09-04 13:25:30 +00001176 parseChildBlock();
Daniel Jasperb88b25f2013-12-23 07:29:06 +00001177 return true;
Manuel Klimekffdeb592013-09-03 15:10:01 +00001178}
1179
1180bool UnwrappedLineParser::tryToParseLambdaIntroducer() {
1181 nextToken();
1182 if (FormatTok->is(tok::equal)) {
1183 nextToken();
Daniel Jasper9a8d48b2013-09-05 10:04:31 +00001184 if (FormatTok->is(tok::r_square)) {
1185 nextToken();
1186 return true;
1187 }
1188 if (FormatTok->isNot(tok::comma))
1189 return false;
Manuel Klimekffdeb592013-09-03 15:10:01 +00001190 nextToken();
1191 } else if (FormatTok->is(tok::amp)) {
1192 nextToken();
Daniel Jasper9a8d48b2013-09-05 10:04:31 +00001193 if (FormatTok->is(tok::r_square)) {
1194 nextToken();
1195 return true;
1196 }
Manuel Klimekffdeb592013-09-03 15:10:01 +00001197 if (!FormatTok->isOneOf(tok::comma, tok::identifier)) {
1198 return false;
1199 }
Daniel Jasper9a8d48b2013-09-05 10:04:31 +00001200 if (FormatTok->is(tok::comma))
1201 nextToken();
Manuel Klimekffdeb592013-09-03 15:10:01 +00001202 } else if (FormatTok->is(tok::r_square)) {
1203 nextToken();
1204 return true;
1205 }
1206 do {
Daniel Jasper9a8d48b2013-09-05 10:04:31 +00001207 if (FormatTok->is(tok::amp))
1208 nextToken();
1209 if (!FormatTok->isOneOf(tok::identifier, tok::kw_this))
1210 return false;
Manuel Klimekffdeb592013-09-03 15:10:01 +00001211 nextToken();
Daniel Jasperda18fd82014-06-10 06:39:03 +00001212 if (FormatTok->is(tok::ellipsis))
1213 nextToken();
Manuel Klimekffdeb592013-09-03 15:10:01 +00001214 if (FormatTok->is(tok::comma)) {
1215 nextToken();
1216 } else if (FormatTok->is(tok::r_square)) {
1217 nextToken();
1218 return true;
1219 } else {
1220 return false;
1221 }
1222 } while (!eof());
1223 return false;
1224}
1225
Daniel Jasperc03e16a2014-05-08 09:25:39 +00001226void UnwrappedLineParser::tryToParseJSFunction() {
Martin Probst409697e2016-05-29 14:41:07 +00001227 assert(FormatTok->is(Keywords.kw_function) ||
1228 FormatTok->startsSequence(Keywords.kw_async, Keywords.kw_function));
Martin Probst5f8445b2016-04-24 22:05:09 +00001229 if (FormatTok->is(Keywords.kw_async))
1230 nextToken();
1231 // Consume "function".
Daniel Jasperc03e16a2014-05-08 09:25:39 +00001232 nextToken();
Daniel Jasper5217a8b2014-06-13 07:02:04 +00001233
Daniel Jasper71e50af2016-11-01 06:22:59 +00001234 // Consume * (generator function). Treat it like C++'s overloaded operators.
1235 if (FormatTok->is(tok::star)) {
1236 FormatTok->Type = TT_OverloadedOperator;
Martin Probst5f8445b2016-04-24 22:05:09 +00001237 nextToken();
Daniel Jasper71e50af2016-11-01 06:22:59 +00001238 }
Martin Probst5f8445b2016-04-24 22:05:09 +00001239
Daniel Jasper5217a8b2014-06-13 07:02:04 +00001240 // Consume function name.
1241 if (FormatTok->is(tok::identifier))
Daniel Jasperfca735c2015-02-19 16:14:18 +00001242 nextToken();
Daniel Jasper5217a8b2014-06-13 07:02:04 +00001243
Daniel Jasperc03e16a2014-05-08 09:25:39 +00001244 if (FormatTok->isNot(tok::l_paren))
1245 return;
Manuel Klimek79e06082015-05-21 12:23:34 +00001246
1247 // Parse formal parameter list.
Daniel Jasperbe520bd2015-05-31 08:51:54 +00001248 parseParens();
Manuel Klimek79e06082015-05-21 12:23:34 +00001249
1250 if (FormatTok->is(tok::colon)) {
1251 // Parse a type definition.
1252 nextToken();
1253
1254 // Eat the type declaration. For braced inline object types, balance braces,
1255 // otherwise just parse until finding an l_brace for the function body.
Daniel Jasperbe520bd2015-05-31 08:51:54 +00001256 if (FormatTok->is(tok::l_brace))
1257 tryToParseBracedList();
1258 else
Martin Probstaf16c502017-01-04 13:36:43 +00001259 while (!FormatTok->isOneOf(tok::l_brace, tok::semi) && !eof())
Manuel Klimek79e06082015-05-21 12:23:34 +00001260 nextToken();
Manuel Klimek79e06082015-05-21 12:23:34 +00001261 }
1262
Martin Probstaf16c502017-01-04 13:36:43 +00001263 if (FormatTok->is(tok::semi))
1264 return;
1265
Manuel Klimek79e06082015-05-21 12:23:34 +00001266 parseChildBlock();
1267}
1268
Daniel Jasper3c883d12015-05-18 14:49:19 +00001269bool UnwrappedLineParser::tryToParseBracedList() {
Daniel Jasperb1f74a82013-07-09 09:06:29 +00001270 if (FormatTok->BlockKind == BK_Unknown)
Daniel Jasper3c883d12015-05-18 14:49:19 +00001271 calculateBraceTypes();
Daniel Jasperb1f74a82013-07-09 09:06:29 +00001272 assert(FormatTok->BlockKind != BK_Unknown);
1273 if (FormatTok->BlockKind == BK_Block)
Manuel Klimekab419912013-05-23 09:41:43 +00001274 return false;
1275 parseBracedList();
1276 return true;
1277}
1278
Daniel Jasper015ed022013-09-13 09:20:45 +00001279bool UnwrappedLineParser::parseBracedList(bool ContinueOnSemicolons) {
1280 bool HasError = false;
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00001281 nextToken();
1282
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00001283 // FIXME: Once we have an expression parser in the UnwrappedLineParser,
1284 // replace this by using parseAssigmentExpression() inside.
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00001285 do {
Manuel Klimek79e06082015-05-21 12:23:34 +00001286 if (Style.Language == FormatStyle::LK_JavaScript) {
Martin Probst409697e2016-05-29 14:41:07 +00001287 if (FormatTok->is(Keywords.kw_function) ||
1288 FormatTok->startsSequence(Keywords.kw_async, Keywords.kw_function)) {
Manuel Klimek79e06082015-05-21 12:23:34 +00001289 tryToParseJSFunction();
1290 continue;
Daniel Jasperbe520bd2015-05-31 08:51:54 +00001291 }
1292 if (FormatTok->is(TT_JsFatArrow)) {
Manuel Klimek79e06082015-05-21 12:23:34 +00001293 nextToken();
1294 // Fat arrows can be followed by simple expressions or by child blocks
1295 // in curly braces.
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00001296 if (FormatTok->is(tok::l_brace)) {
Manuel Klimek79e06082015-05-21 12:23:34 +00001297 parseChildBlock();
1298 continue;
1299 }
1300 }
Daniel Jasperc03e16a2014-05-08 09:25:39 +00001301 }
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001302 switch (FormatTok->Tok.getKind()) {
Manuel Klimek516e0542013-09-04 13:25:30 +00001303 case tok::caret:
1304 nextToken();
1305 if (FormatTok->is(tok::l_brace)) {
1306 parseChildBlock();
1307 }
1308 break;
1309 case tok::l_square:
1310 tryToParseLambda();
1311 break;
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00001312 case tok::l_brace:
Manuel Klimekbab25fd2013-09-04 08:20:47 +00001313 // Assume there are no blocks inside a braced init list apart
1314 // from the ones we explicitly parse out (like lambdas).
1315 FormatTok->BlockKind = BK_BracedInit;
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00001316 parseBracedList();
1317 break;
Daniel Jaspera87af7a2015-06-30 11:32:22 +00001318 case tok::l_paren:
1319 parseParens();
Daniel Jasperf46dec82015-03-31 14:34:15 +00001320 // JavaScript can just have free standing methods and getters/setters in
1321 // object literals. Detect them by a "{" following ")".
1322 if (Style.Language == FormatStyle::LK_JavaScript) {
Daniel Jasperf46dec82015-03-31 14:34:15 +00001323 if (FormatTok->is(tok::l_brace))
1324 parseChildBlock();
1325 break;
1326 }
Daniel Jasperf46dec82015-03-31 14:34:15 +00001327 break;
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00001328 case tok::r_brace:
1329 nextToken();
Daniel Jasper015ed022013-09-13 09:20:45 +00001330 return !HasError;
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00001331 case tok::semi:
Daniel Jasperb9a49902016-01-09 15:56:28 +00001332 // JavaScript (or more precisely TypeScript) can have semicolons in braced
1333 // lists (in so-called TypeMemberLists). Thus, the semicolon cannot be
1334 // used for error recovery if we have otherwise determined that this is
1335 // a braced list.
1336 if (Style.Language == FormatStyle::LK_JavaScript) {
1337 nextToken();
1338 break;
1339 }
Daniel Jasper015ed022013-09-13 09:20:45 +00001340 HasError = true;
1341 if (!ContinueOnSemicolons)
1342 return !HasError;
1343 nextToken();
1344 break;
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00001345 case tok::comma:
1346 nextToken();
Manuel Klimeka3ff45e2013-04-10 09:52:05 +00001347 break;
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00001348 default:
1349 nextToken();
1350 break;
1351 }
1352 } while (!eof());
Daniel Jasper015ed022013-09-13 09:20:45 +00001353 return false;
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00001354}
1355
Daniel Jasperf7935112012-12-03 18:12:45 +00001356void UnwrappedLineParser::parseParens() {
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001357 assert(FormatTok->Tok.is(tok::l_paren) && "'(' expected.");
Daniel Jasperf7935112012-12-03 18:12:45 +00001358 nextToken();
1359 do {
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001360 switch (FormatTok->Tok.getKind()) {
Daniel Jasperf7935112012-12-03 18:12:45 +00001361 case tok::l_paren:
1362 parseParens();
Daniel Jasper5f1fa852015-01-04 20:40:51 +00001363 if (Style.Language == FormatStyle::LK_Java && FormatTok->is(tok::l_brace))
1364 parseChildBlock();
Daniel Jasperf7935112012-12-03 18:12:45 +00001365 break;
1366 case tok::r_paren:
1367 nextToken();
1368 return;
Daniel Jasper393564f2013-05-31 14:56:29 +00001369 case tok::r_brace:
1370 // A "}" inside parenthesis is an error if there wasn't a matching "{".
1371 return;
Daniel Jasper9a8d48b2013-09-05 10:04:31 +00001372 case tok::l_square:
1373 tryToParseLambda();
1374 break;
Daniel Jasper5f1fa852015-01-04 20:40:51 +00001375 case tok::l_brace:
Daniel Jasperadba2aa2015-05-18 12:52:00 +00001376 if (!tryToParseBracedList())
Manuel Klimekf017dc02013-09-04 13:34:14 +00001377 parseChildBlock();
Manuel Klimek8e07a1b2013-01-10 11:52:21 +00001378 break;
Nico Weber372d8dc2013-02-10 20:35:35 +00001379 case tok::at:
1380 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001381 if (FormatTok->Tok.is(tok::l_brace))
Nico Weber372d8dc2013-02-10 20:35:35 +00001382 parseBracedList();
1383 break;
Daniel Jasper3f69ba12014-09-05 08:42:27 +00001384 case tok::identifier:
1385 if (Style.Language == FormatStyle::LK_JavaScript &&
Martin Probst409697e2016-05-29 14:41:07 +00001386 (FormatTok->is(Keywords.kw_function) ||
1387 FormatTok->startsSequence(Keywords.kw_async, Keywords.kw_function)))
Daniel Jasper3f69ba12014-09-05 08:42:27 +00001388 tryToParseJSFunction();
1389 else
1390 nextToken();
1391 break;
Daniel Jasperf7935112012-12-03 18:12:45 +00001392 default:
1393 nextToken();
1394 break;
1395 }
1396 } while (!eof());
1397}
1398
Daniel Jasperb88b25f2013-12-23 07:29:06 +00001399void UnwrappedLineParser::parseSquare() {
1400 assert(FormatTok->Tok.is(tok::l_square) && "'[' expected.");
1401 if (tryToParseLambda())
1402 return;
1403 do {
Daniel Jasperb88b25f2013-12-23 07:29:06 +00001404 switch (FormatTok->Tok.getKind()) {
1405 case tok::l_paren:
1406 parseParens();
1407 break;
1408 case tok::r_square:
1409 nextToken();
1410 return;
1411 case tok::r_brace:
1412 // A "}" inside parenthesis is an error if there wasn't a matching "{".
1413 return;
1414 case tok::l_square:
1415 parseSquare();
1416 break;
1417 case tok::l_brace: {
Daniel Jasperadba2aa2015-05-18 12:52:00 +00001418 if (!tryToParseBracedList())
Daniel Jasperb88b25f2013-12-23 07:29:06 +00001419 parseChildBlock();
Daniel Jasperb88b25f2013-12-23 07:29:06 +00001420 break;
1421 }
1422 case tok::at:
1423 nextToken();
1424 if (FormatTok->Tok.is(tok::l_brace))
1425 parseBracedList();
1426 break;
1427 default:
1428 nextToken();
1429 break;
1430 }
1431 } while (!eof());
1432}
1433
Daniel Jasperf7935112012-12-03 18:12:45 +00001434void UnwrappedLineParser::parseIfThenElse() {
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001435 assert(FormatTok->Tok.is(tok::kw_if) && "'if' expected");
Daniel Jasperf7935112012-12-03 18:12:45 +00001436 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001437 if (FormatTok->Tok.is(tok::l_paren))
Manuel Klimekadededf2013-01-11 18:28:36 +00001438 parseParens();
Daniel Jasperf7935112012-12-03 18:12:45 +00001439 bool NeedsUnwrappedLine = false;
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001440 if (FormatTok->Tok.is(tok::l_brace)) {
Alexander Kornienko3a33f022013-12-12 09:49:52 +00001441 CompoundStatementIndenter Indenter(this, Style, Line->Level);
Nico Weber9096fc02013-06-26 00:30:14 +00001442 parseBlock(/*MustBeDeclaration=*/false);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00001443 if (Style.BraceWrapping.BeforeElse)
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00001444 addUnwrappedLine();
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00001445 else
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00001446 NeedsUnwrappedLine = true;
Daniel Jasperf7935112012-12-03 18:12:45 +00001447 } else {
1448 addUnwrappedLine();
Manuel Klimek52b15152013-01-09 15:25:02 +00001449 ++Line->Level;
Manuel Klimek6b9eeba2013-01-07 14:56:16 +00001450 parseStructuralElement();
Manuel Klimek52b15152013-01-09 15:25:02 +00001451 --Line->Level;
Daniel Jasperf7935112012-12-03 18:12:45 +00001452 }
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001453 if (FormatTok->Tok.is(tok::kw_else)) {
Daniel Jasperf7935112012-12-03 18:12:45 +00001454 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001455 if (FormatTok->Tok.is(tok::l_brace)) {
Alexander Kornienko3a33f022013-12-12 09:49:52 +00001456 CompoundStatementIndenter Indenter(this, Style, Line->Level);
Nico Weber9096fc02013-06-26 00:30:14 +00001457 parseBlock(/*MustBeDeclaration=*/false);
Daniel Jasperf7935112012-12-03 18:12:45 +00001458 addUnwrappedLine();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001459 } else if (FormatTok->Tok.is(tok::kw_if)) {
Daniel Jasperf7935112012-12-03 18:12:45 +00001460 parseIfThenElse();
1461 } else {
1462 addUnwrappedLine();
Manuel Klimek52b15152013-01-09 15:25:02 +00001463 ++Line->Level;
Manuel Klimek6b9eeba2013-01-07 14:56:16 +00001464 parseStructuralElement();
Daniel Jasper451544a2016-05-19 06:30:48 +00001465 if (FormatTok->is(tok::eof))
1466 addUnwrappedLine();
Manuel Klimek52b15152013-01-09 15:25:02 +00001467 --Line->Level;
Daniel Jasperf7935112012-12-03 18:12:45 +00001468 }
1469 } else if (NeedsUnwrappedLine) {
1470 addUnwrappedLine();
1471 }
1472}
1473
Daniel Jasper04a71a42014-05-08 11:58:24 +00001474void UnwrappedLineParser::parseTryCatch() {
Nico Weberfac23712015-02-04 15:26:27 +00001475 assert(FormatTok->isOneOf(tok::kw_try, tok::kw___try) && "'try' expected");
Daniel Jasper04a71a42014-05-08 11:58:24 +00001476 nextToken();
1477 bool NeedsUnwrappedLine = false;
1478 if (FormatTok->is(tok::colon)) {
1479 // We are in a function try block, what comes is an initializer list.
1480 nextToken();
1481 while (FormatTok->is(tok::identifier)) {
1482 nextToken();
1483 if (FormatTok->is(tok::l_paren))
1484 parseParens();
Daniel Jasper04a71a42014-05-08 11:58:24 +00001485 if (FormatTok->is(tok::comma))
1486 nextToken();
1487 }
1488 }
Daniel Jaspere189d462015-01-14 10:48:41 +00001489 // Parse try with resource.
1490 if (Style.Language == FormatStyle::LK_Java && FormatTok->is(tok::l_paren)) {
1491 parseParens();
1492 }
Daniel Jasper04a71a42014-05-08 11:58:24 +00001493 if (FormatTok->is(tok::l_brace)) {
1494 CompoundStatementIndenter Indenter(this, Style, Line->Level);
1495 parseBlock(/*MustBeDeclaration=*/false);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00001496 if (Style.BraceWrapping.BeforeCatch) {
Daniel Jasper04a71a42014-05-08 11:58:24 +00001497 addUnwrappedLine();
1498 } else {
1499 NeedsUnwrappedLine = true;
1500 }
1501 } else if (!FormatTok->is(tok::kw_catch)) {
1502 // The C++ standard requires a compound-statement after a try.
1503 // If there's none, we try to assume there's a structuralElement
1504 // and try to continue.
Daniel Jasper04a71a42014-05-08 11:58:24 +00001505 addUnwrappedLine();
1506 ++Line->Level;
1507 parseStructuralElement();
1508 --Line->Level;
1509 }
Nico Weber33381f52015-02-07 01:57:32 +00001510 while (1) {
1511 if (FormatTok->is(tok::at))
1512 nextToken();
1513 if (!(FormatTok->isOneOf(tok::kw_catch, Keywords.kw___except,
1514 tok::kw___finally) ||
1515 ((Style.Language == FormatStyle::LK_Java ||
1516 Style.Language == FormatStyle::LK_JavaScript) &&
1517 FormatTok->is(Keywords.kw_finally)) ||
1518 (FormatTok->Tok.isObjCAtKeyword(tok::objc_catch) ||
1519 FormatTok->Tok.isObjCAtKeyword(tok::objc_finally))))
1520 break;
Daniel Jasper04a71a42014-05-08 11:58:24 +00001521 nextToken();
1522 while (FormatTok->isNot(tok::l_brace)) {
1523 if (FormatTok->is(tok::l_paren)) {
1524 parseParens();
1525 continue;
1526 }
Daniel Jasper2bd7a642015-01-19 10:50:51 +00001527 if (FormatTok->isOneOf(tok::semi, tok::r_brace, tok::eof))
Daniel Jasper04a71a42014-05-08 11:58:24 +00001528 return;
1529 nextToken();
1530 }
1531 NeedsUnwrappedLine = false;
1532 CompoundStatementIndenter Indenter(this, Style, Line->Level);
1533 parseBlock(/*MustBeDeclaration=*/false);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00001534 if (Style.BraceWrapping.BeforeCatch)
Daniel Jasper04a71a42014-05-08 11:58:24 +00001535 addUnwrappedLine();
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00001536 else
Daniel Jasper04a71a42014-05-08 11:58:24 +00001537 NeedsUnwrappedLine = true;
Daniel Jasper04a71a42014-05-08 11:58:24 +00001538 }
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00001539 if (NeedsUnwrappedLine)
Daniel Jasper04a71a42014-05-08 11:58:24 +00001540 addUnwrappedLine();
Daniel Jasper04a71a42014-05-08 11:58:24 +00001541}
1542
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001543void UnwrappedLineParser::parseNamespace() {
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001544 assert(FormatTok->Tok.is(tok::kw_namespace) && "'namespace' expected");
Roman Kashitsyna043ced2014-08-11 12:18:01 +00001545
1546 const FormatToken &InitialToken = *FormatTok;
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001547 nextToken();
Saleem Abdulrasool328085f2015-10-30 05:07:56 +00001548 while (FormatTok->isOneOf(tok::identifier, tok::coloncolon))
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001549 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001550 if (FormatTok->Tok.is(tok::l_brace)) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00001551 if (ShouldBreakBeforeBrace(Style, InitialToken))
Manuel Klimeka8eb9142013-05-13 12:51:40 +00001552 addUnwrappedLine();
1553
Daniel Jasper65ee3472013-07-31 23:16:02 +00001554 bool AddLevel = Style.NamespaceIndentation == FormatStyle::NI_All ||
1555 (Style.NamespaceIndentation == FormatStyle::NI_Inner &&
1556 DeclarationScopeStack.size() > 1);
1557 parseBlock(/*MustBeDeclaration=*/true, AddLevel);
Manuel Klimek046b9302013-02-06 16:08:09 +00001558 // Munch the semicolon after a namespace. This is more common than one would
1559 // think. Puttin the semicolon into its own line is very ugly.
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001560 if (FormatTok->Tok.is(tok::semi))
Manuel Klimek046b9302013-02-06 16:08:09 +00001561 nextToken();
Alexander Kornienko578fdd82012-12-06 18:03:27 +00001562 addUnwrappedLine();
1563 }
1564 // FIXME: Add error handling.
1565}
1566
Daniel Jasper6acf5132015-03-12 14:44:29 +00001567void UnwrappedLineParser::parseNew() {
1568 assert(FormatTok->is(tok::kw_new) && "'new' expected");
1569 nextToken();
1570 if (Style.Language != FormatStyle::LK_Java)
1571 return;
1572
1573 // In Java, we can parse everything up to the parens, which aren't optional.
1574 do {
1575 // There should not be a ;, { or } before the new's open paren.
1576 if (FormatTok->isOneOf(tok::semi, tok::l_brace, tok::r_brace))
1577 return;
1578
1579 // Consume the parens.
1580 if (FormatTok->is(tok::l_paren)) {
1581 parseParens();
1582
1583 // If there is a class body of an anonymous class, consume that as child.
1584 if (FormatTok->is(tok::l_brace))
1585 parseChildBlock();
1586 return;
1587 }
1588 nextToken();
1589 } while (!eof());
1590}
1591
Alexander Kornienko37d6c942012-12-05 15:06:06 +00001592void UnwrappedLineParser::parseForOrWhileLoop() {
Daniel Jasper66cb8c52015-05-04 09:22:29 +00001593 assert(FormatTok->isOneOf(tok::kw_for, tok::kw_while, TT_ForEachMacro) &&
Daniel Jaspere1e43192014-04-01 12:55:11 +00001594 "'for', 'while' or foreach macro expected");
Alexander Kornienko37d6c942012-12-05 15:06:06 +00001595 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001596 if (FormatTok->Tok.is(tok::l_paren))
Manuel Klimek9fa8d552013-01-11 19:23:05 +00001597 parseParens();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001598 if (FormatTok->Tok.is(tok::l_brace)) {
Alexander Kornienko3a33f022013-12-12 09:49:52 +00001599 CompoundStatementIndenter Indenter(this, Style, Line->Level);
Nico Weber9096fc02013-06-26 00:30:14 +00001600 parseBlock(/*MustBeDeclaration=*/false);
Alexander Kornienko37d6c942012-12-05 15:06:06 +00001601 addUnwrappedLine();
1602 } else {
1603 addUnwrappedLine();
Manuel Klimek52b15152013-01-09 15:25:02 +00001604 ++Line->Level;
Manuel Klimek6b9eeba2013-01-07 14:56:16 +00001605 parseStructuralElement();
Manuel Klimek52b15152013-01-09 15:25:02 +00001606 --Line->Level;
Alexander Kornienko37d6c942012-12-05 15:06:06 +00001607 }
1608}
1609
Daniel Jasperf7935112012-12-03 18:12:45 +00001610void UnwrappedLineParser::parseDoWhile() {
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001611 assert(FormatTok->Tok.is(tok::kw_do) && "'do' expected");
Daniel Jasperf7935112012-12-03 18:12:45 +00001612 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001613 if (FormatTok->Tok.is(tok::l_brace)) {
Alexander Kornienko3a33f022013-12-12 09:49:52 +00001614 CompoundStatementIndenter Indenter(this, Style, Line->Level);
Nico Weber9096fc02013-06-26 00:30:14 +00001615 parseBlock(/*MustBeDeclaration=*/false);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00001616 if (Style.BraceWrapping.IndentBraces)
Alexander Kornienko3a33f022013-12-12 09:49:52 +00001617 addUnwrappedLine();
Daniel Jasperf7935112012-12-03 18:12:45 +00001618 } else {
1619 addUnwrappedLine();
Manuel Klimek52b15152013-01-09 15:25:02 +00001620 ++Line->Level;
Manuel Klimek6b9eeba2013-01-07 14:56:16 +00001621 parseStructuralElement();
Manuel Klimek52b15152013-01-09 15:25:02 +00001622 --Line->Level;
Daniel Jasperf7935112012-12-03 18:12:45 +00001623 }
1624
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00001625 // FIXME: Add error handling.
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001626 if (!FormatTok->Tok.is(tok::kw_while)) {
Alexander Kornienko0ea8e102012-12-04 15:40:36 +00001627 addUnwrappedLine();
1628 return;
1629 }
1630
Daniel Jasperf7935112012-12-03 18:12:45 +00001631 nextToken();
Manuel Klimek6b9eeba2013-01-07 14:56:16 +00001632 parseStructuralElement();
Daniel Jasperf7935112012-12-03 18:12:45 +00001633}
1634
1635void UnwrappedLineParser::parseLabel() {
Daniel Jasperf7935112012-12-03 18:12:45 +00001636 nextToken();
Manuel Klimek52b15152013-01-09 15:25:02 +00001637 unsigned OldLineLevel = Line->Level;
Daniel Jaspera1275122013-03-20 10:23:53 +00001638 if (Line->Level > 1 || (!Line->InPPDirective && Line->Level > 0))
Manuel Klimek52b15152013-01-09 15:25:02 +00001639 --Line->Level;
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001640 if (CommentsBeforeNextToken.empty() && FormatTok->Tok.is(tok::l_brace)) {
Alexander Kornienko3a33f022013-12-12 09:49:52 +00001641 CompoundStatementIndenter Indenter(this, Style, Line->Level);
Nico Weber9096fc02013-06-26 00:30:14 +00001642 parseBlock(/*MustBeDeclaration=*/false);
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00001643 if (FormatTok->Tok.is(tok::kw_break)) {
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00001644 if (Style.BraceWrapping.AfterControlStatement)
Manuel Klimekd3ed59a2013-08-02 21:31:59 +00001645 addUnwrappedLine();
1646 parseStructuralElement();
1647 }
Alexander Kornienko3a33f022013-12-12 09:49:52 +00001648 addUnwrappedLine();
1649 } else {
Daniel Jasper1fe0d5c2015-05-06 15:19:47 +00001650 if (FormatTok->is(tok::semi))
1651 nextToken();
Alexander Kornienko3a33f022013-12-12 09:49:52 +00001652 addUnwrappedLine();
Daniel Jasperf7935112012-12-03 18:12:45 +00001653 }
Manuel Klimek52b15152013-01-09 15:25:02 +00001654 Line->Level = OldLineLevel;
Daniel Jasper2cce7b72016-04-06 16:41:39 +00001655 if (FormatTok->isNot(tok::l_brace)) {
Daniel Jasper40609472016-04-06 15:02:46 +00001656 parseStructuralElement();
Daniel Jasper2cce7b72016-04-06 16:41:39 +00001657 addUnwrappedLine();
1658 }
Daniel Jasperf7935112012-12-03 18:12:45 +00001659}
1660
1661void UnwrappedLineParser::parseCaseLabel() {
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001662 assert(FormatTok->Tok.is(tok::kw_case) && "'case' expected");
Daniel Jasperf7935112012-12-03 18:12:45 +00001663 // FIXME: fix handling of complex expressions here.
1664 do {
1665 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001666 } while (!eof() && !FormatTok->Tok.is(tok::colon));
Daniel Jasperf7935112012-12-03 18:12:45 +00001667 parseLabel();
1668}
1669
1670void UnwrappedLineParser::parseSwitch() {
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001671 assert(FormatTok->Tok.is(tok::kw_switch) && "'switch' expected");
Daniel Jasperf7935112012-12-03 18:12:45 +00001672 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001673 if (FormatTok->Tok.is(tok::l_paren))
Manuel Klimek9fa8d552013-01-11 19:23:05 +00001674 parseParens();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001675 if (FormatTok->Tok.is(tok::l_brace)) {
Alexander Kornienko3a33f022013-12-12 09:49:52 +00001676 CompoundStatementIndenter Indenter(this, Style, Line->Level);
Daniel Jasper65ee3472013-07-31 23:16:02 +00001677 parseBlock(/*MustBeDeclaration=*/false);
Daniel Jasperf7935112012-12-03 18:12:45 +00001678 addUnwrappedLine();
1679 } else {
1680 addUnwrappedLine();
Daniel Jasper516d7972013-07-25 11:31:57 +00001681 ++Line->Level;
Manuel Klimek6b9eeba2013-01-07 14:56:16 +00001682 parseStructuralElement();
Daniel Jasper516d7972013-07-25 11:31:57 +00001683 --Line->Level;
Daniel Jasperf7935112012-12-03 18:12:45 +00001684 }
1685}
1686
1687void UnwrappedLineParser::parseAccessSpecifier() {
1688 nextToken();
Daniel Jasper84c47a12013-11-23 17:53:41 +00001689 // Understand Qt's slots.
Daniel Jasper53395402015-04-07 15:04:40 +00001690 if (FormatTok->isOneOf(Keywords.kw_slots, Keywords.kw_qslots))
Daniel Jasper84c47a12013-11-23 17:53:41 +00001691 nextToken();
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00001692 // Otherwise, we don't know what it is, and we'd better keep the next token.
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001693 if (FormatTok->Tok.is(tok::colon))
Alexander Kornienko2ca766f2012-12-10 16:34:48 +00001694 nextToken();
Daniel Jasperf7935112012-12-03 18:12:45 +00001695 addUnwrappedLine();
1696}
1697
Daniel Jasper6f5a1932015-12-29 08:54:23 +00001698bool UnwrappedLineParser::parseEnum() {
Daniel Jasper6be0f552014-11-13 15:56:28 +00001699 // Won't be 'enum' for NS_ENUMs.
1700 if (FormatTok->Tok.is(tok::kw_enum))
Daniel Jasperccb68b42014-11-19 22:38:18 +00001701 nextToken();
Daniel Jasper6be0f552014-11-13 15:56:28 +00001702
Daniel Jasper6f5a1932015-12-29 08:54:23 +00001703 // In TypeScript, "enum" can also be used as property name, e.g. in interface
1704 // declarations. An "enum" keyword followed by a colon would be a syntax
1705 // error and thus assume it is just an identifier.
Daniel Jasper87379302016-02-03 05:33:44 +00001706 if (Style.Language == FormatStyle::LK_JavaScript &&
1707 FormatTok->isOneOf(tok::colon, tok::question))
Daniel Jasper6f5a1932015-12-29 08:54:23 +00001708 return false;
1709
Daniel Jasper2b41a822013-08-20 12:42:50 +00001710 // Eat up enum class ...
Daniel Jasperb05a81d2014-05-09 13:11:16 +00001711 if (FormatTok->Tok.is(tok::kw_class) || FormatTok->Tok.is(tok::kw_struct))
1712 nextToken();
Daniel Jasperb5a0b852015-06-19 08:17:32 +00001713
Daniel Jasper786a5502013-09-06 21:32:35 +00001714 while (FormatTok->Tok.getIdentifierInfo() ||
Daniel Jasperccb68b42014-11-19 22:38:18 +00001715 FormatTok->isOneOf(tok::colon, tok::coloncolon, tok::less,
1716 tok::greater, tok::comma, tok::question)) {
Manuel Klimek2cec0192013-01-21 19:17:52 +00001717 nextToken();
1718 // We can have macros or attributes in between 'enum' and the enum name.
Daniel Jasperccb68b42014-11-19 22:38:18 +00001719 if (FormatTok->is(tok::l_paren))
Alexander Kornienkob7076a22012-12-04 14:46:19 +00001720 parseParens();
Daniel Jasperb5a0b852015-06-19 08:17:32 +00001721 if (FormatTok->is(tok::identifier)) {
Manuel Klimek2cec0192013-01-21 19:17:52 +00001722 nextToken();
Daniel Jasperb5a0b852015-06-19 08:17:32 +00001723 // If there are two identifiers in a row, this is likely an elaborate
1724 // return type. In Java, this can be "implements", etc.
1725 if (Style.Language == FormatStyle::LK_Cpp &&
1726 FormatTok->is(tok::identifier))
Daniel Jasper6f5a1932015-12-29 08:54:23 +00001727 return false;
Daniel Jasperb5a0b852015-06-19 08:17:32 +00001728 }
Manuel Klimek2cec0192013-01-21 19:17:52 +00001729 }
Daniel Jasper6be0f552014-11-13 15:56:28 +00001730
1731 // Just a declaration or something is wrong.
Daniel Jasperccb68b42014-11-19 22:38:18 +00001732 if (FormatTok->isNot(tok::l_brace))
Daniel Jasper6f5a1932015-12-29 08:54:23 +00001733 return true;
Daniel Jasper6be0f552014-11-13 15:56:28 +00001734 FormatTok->BlockKind = BK_Block;
1735
1736 if (Style.Language == FormatStyle::LK_Java) {
1737 // Java enums are different.
1738 parseJavaEnumBody();
Daniel Jasper6f5a1932015-12-29 08:54:23 +00001739 return true;
1740 }
1741 if (Style.Language == FormatStyle::LK_Proto) {
Daniel Jasperc6dd2732015-07-16 14:25:43 +00001742 parseBlock(/*MustBeDeclaration=*/true);
Daniel Jasper6f5a1932015-12-29 08:54:23 +00001743 return true;
Manuel Klimek2cec0192013-01-21 19:17:52 +00001744 }
Daniel Jasper6be0f552014-11-13 15:56:28 +00001745
1746 // Parse enum body.
1747 bool HasError = !parseBracedList(/*ContinueOnSemicolons=*/true);
1748 if (HasError) {
1749 if (FormatTok->is(tok::semi))
1750 nextToken();
1751 addUnwrappedLine();
1752 }
Daniel Jasper6f5a1932015-12-29 08:54:23 +00001753 return true;
Daniel Jasper6be0f552014-11-13 15:56:28 +00001754
Daniel Jasper90cf3802015-06-17 09:44:02 +00001755 // There is no addUnwrappedLine() here so that we fall through to parsing a
1756 // structural element afterwards. Thus, in "enum A {} n, m;",
Manuel Klimek2cec0192013-01-21 19:17:52 +00001757 // "} n, m;" will end up in one unwrapped line.
Daniel Jasper6be0f552014-11-13 15:56:28 +00001758}
1759
1760void UnwrappedLineParser::parseJavaEnumBody() {
1761 // Determine whether the enum is simple, i.e. does not have a semicolon or
1762 // constants with class bodies. Simple enums can be formatted like braced
1763 // lists, contracted to a single line, etc.
1764 unsigned StoredPosition = Tokens->getPosition();
1765 bool IsSimple = true;
1766 FormatToken *Tok = Tokens->getNextToken();
1767 while (Tok) {
1768 if (Tok->is(tok::r_brace))
1769 break;
1770 if (Tok->isOneOf(tok::l_brace, tok::semi)) {
1771 IsSimple = false;
1772 break;
1773 }
1774 // FIXME: This will also mark enums with braces in the arguments to enum
1775 // constants as "not simple". This is probably fine in practice, though.
1776 Tok = Tokens->getNextToken();
1777 }
1778 FormatTok = Tokens->setPosition(StoredPosition);
1779
1780 if (IsSimple) {
1781 parseBracedList();
Daniel Jasperdf2ff002014-11-02 22:31:39 +00001782 addUnwrappedLine();
Daniel Jasper6be0f552014-11-13 15:56:28 +00001783 return;
1784 }
1785
1786 // Parse the body of a more complex enum.
1787 // First add a line for everything up to the "{".
1788 nextToken();
1789 addUnwrappedLine();
1790 ++Line->Level;
1791
1792 // Parse the enum constants.
1793 while (FormatTok) {
1794 if (FormatTok->is(tok::l_brace)) {
1795 // Parse the constant's class body.
1796 parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/true,
1797 /*MunchSemi=*/false);
1798 } else if (FormatTok->is(tok::l_paren)) {
1799 parseParens();
1800 } else if (FormatTok->is(tok::comma)) {
1801 nextToken();
1802 addUnwrappedLine();
1803 } else if (FormatTok->is(tok::semi)) {
1804 nextToken();
1805 addUnwrappedLine();
1806 break;
1807 } else if (FormatTok->is(tok::r_brace)) {
1808 addUnwrappedLine();
1809 break;
1810 } else {
1811 nextToken();
1812 }
1813 }
1814
1815 // Parse the class body after the enum's ";" if any.
1816 parseLevel(/*HasOpeningBrace=*/true);
1817 nextToken();
1818 --Line->Level;
1819 addUnwrappedLine();
Daniel Jasperf7935112012-12-03 18:12:45 +00001820}
1821
Manuel Klimeke01bab52013-01-15 13:38:33 +00001822void UnwrappedLineParser::parseRecord() {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00001823 const FormatToken &InitialToken = *FormatTok;
Manuel Klimek28cacc72013-01-07 18:10:23 +00001824 nextToken();
Daniel Jasper04785d02015-05-06 14:03:02 +00001825
Daniel Jasper04785d02015-05-06 14:03:02 +00001826 // The actual identifier can be a nested name specifier, and in macros
1827 // it is often token-pasted.
1828 while (FormatTok->isOneOf(tok::identifier, tok::coloncolon, tok::hashhash,
1829 tok::kw___attribute, tok::kw___declspec,
1830 tok::kw_alignas) ||
1831 ((Style.Language == FormatStyle::LK_Java ||
1832 Style.Language == FormatStyle::LK_JavaScript) &&
1833 FormatTok->isOneOf(tok::period, tok::comma))) {
1834 bool IsNonMacroIdentifier =
1835 FormatTok->is(tok::identifier) &&
1836 FormatTok->TokenText != FormatTok->TokenText.upper();
Manuel Klimeke01bab52013-01-15 13:38:33 +00001837 nextToken();
1838 // We can have macros or attributes in between 'class' and the class name.
Daniel Jasper04785d02015-05-06 14:03:02 +00001839 if (!IsNonMacroIdentifier && FormatTok->Tok.is(tok::l_paren))
Manuel Klimeke01bab52013-01-15 13:38:33 +00001840 parseParens();
Daniel Jasper04785d02015-05-06 14:03:02 +00001841 }
Manuel Klimeke01bab52013-01-15 13:38:33 +00001842
Daniel Jasper04785d02015-05-06 14:03:02 +00001843 // Note that parsing away template declarations here leads to incorrectly
1844 // accepting function declarations as record declarations.
1845 // In general, we cannot solve this problem. Consider:
1846 // class A<int> B() {}
1847 // which can be a function definition or a class definition when B() is a
1848 // macro. If we find enough real-world cases where this is a problem, we
1849 // can parse for the 'template' keyword in the beginning of the statement,
1850 // and thus rule out the record production in case there is no template
1851 // (this would still leave us with an ambiguity between template function
1852 // and class declarations).
Daniel Jasperadba2aa2015-05-18 12:52:00 +00001853 if (FormatTok->isOneOf(tok::colon, tok::less)) {
1854 while (!eof()) {
Daniel Jasper3c883d12015-05-18 14:49:19 +00001855 if (FormatTok->is(tok::l_brace)) {
1856 calculateBraceTypes(/*ExpectClassBody=*/true);
1857 if (!tryToParseBracedList())
1858 break;
1859 }
Daniel Jasper04785d02015-05-06 14:03:02 +00001860 if (FormatTok->Tok.is(tok::semi))
1861 return;
1862 nextToken();
Manuel Klimeke01bab52013-01-15 13:38:33 +00001863 }
1864 }
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001865 if (FormatTok->Tok.is(tok::l_brace)) {
Roman Kashitsyna043ced2014-08-11 12:18:01 +00001866 if (ShouldBreakBeforeBrace(Style, InitialToken))
Manuel Klimeka8eb9142013-05-13 12:51:40 +00001867 addUnwrappedLine();
1868
Daniel Jasper240dfda2014-03-31 14:23:49 +00001869 parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/true,
Manuel Klimekb212f3b2013-10-12 22:46:56 +00001870 /*MunchSemi=*/false);
Manuel Klimeka8eb9142013-05-13 12:51:40 +00001871 }
Daniel Jasper90cf3802015-06-17 09:44:02 +00001872 // There is no addUnwrappedLine() here so that we fall through to parsing a
1873 // structural element afterwards. Thus, in "class A {} n, m;",
1874 // "} n, m;" will end up in one unwrapped line.
Manuel Klimek28cacc72013-01-07 18:10:23 +00001875}
1876
Nico Weber8696a8d2013-01-09 21:15:03 +00001877void UnwrappedLineParser::parseObjCProtocolList() {
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001878 assert(FormatTok->Tok.is(tok::less) && "'<' expected.");
Nico Weber8696a8d2013-01-09 21:15:03 +00001879 do
1880 nextToken();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001881 while (!eof() && FormatTok->Tok.isNot(tok::greater));
Nico Weber8696a8d2013-01-09 21:15:03 +00001882 nextToken(); // Skip '>'.
1883}
1884
1885void UnwrappedLineParser::parseObjCUntilAtEnd() {
1886 do {
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001887 if (FormatTok->Tok.isObjCAtKeyword(tok::objc_end)) {
Nico Weber8696a8d2013-01-09 21:15:03 +00001888 nextToken();
1889 addUnwrappedLine();
1890 break;
1891 }
Daniel Jaspera15da302013-08-28 08:04:23 +00001892 if (FormatTok->is(tok::l_brace)) {
1893 parseBlock(/*MustBeDeclaration=*/false);
1894 // In ObjC interfaces, nothing should be following the "}".
1895 addUnwrappedLine();
Benjamin Kramere21cb742014-01-08 15:59:42 +00001896 } else if (FormatTok->is(tok::r_brace)) {
1897 // Ignore stray "}". parseStructuralElement doesn't consume them.
1898 nextToken();
1899 addUnwrappedLine();
Daniel Jaspera15da302013-08-28 08:04:23 +00001900 } else {
1901 parseStructuralElement();
1902 }
Nico Weber8696a8d2013-01-09 21:15:03 +00001903 } while (!eof());
1904}
1905
Nico Weber2ce0ac52013-01-09 23:25:37 +00001906void UnwrappedLineParser::parseObjCInterfaceOrImplementation() {
Nico Weber7eecf4b2013-01-09 20:25:35 +00001907 nextToken();
Daniel Jasperd1ae3582013-03-20 12:37:50 +00001908 nextToken(); // interface name
Nico Weber7eecf4b2013-01-09 20:25:35 +00001909
1910 // @interface can be followed by either a base class, or a category.
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001911 if (FormatTok->Tok.is(tok::colon)) {
Nico Weber7eecf4b2013-01-09 20:25:35 +00001912 nextToken();
Daniel Jasperd1ae3582013-03-20 12:37:50 +00001913 nextToken(); // base class name
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001914 } else if (FormatTok->Tok.is(tok::l_paren))
Nico Weber7eecf4b2013-01-09 20:25:35 +00001915 // Skip category, if present.
1916 parseParens();
1917
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001918 if (FormatTok->Tok.is(tok::less))
Nico Weber8696a8d2013-01-09 21:15:03 +00001919 parseObjCProtocolList();
Nico Weber7eecf4b2013-01-09 20:25:35 +00001920
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00001921 if (FormatTok->Tok.is(tok::l_brace)) {
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00001922 if (Style.BraceWrapping.AfterObjCDeclaration)
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00001923 addUnwrappedLine();
Nico Weber9096fc02013-06-26 00:30:14 +00001924 parseBlock(/*MustBeDeclaration=*/true);
Dinesh Dwivediea3aca82014-05-02 17:01:46 +00001925 }
Nico Weber7eecf4b2013-01-09 20:25:35 +00001926
1927 // With instance variables, this puts '}' on its own line. Without instance
1928 // variables, this ends the @interface line.
1929 addUnwrappedLine();
1930
Nico Weber8696a8d2013-01-09 21:15:03 +00001931 parseObjCUntilAtEnd();
1932}
Nico Weber7eecf4b2013-01-09 20:25:35 +00001933
Nico Weber8696a8d2013-01-09 21:15:03 +00001934void UnwrappedLineParser::parseObjCProtocol() {
1935 nextToken();
Daniel Jasperd1ae3582013-03-20 12:37:50 +00001936 nextToken(); // protocol name
Nico Weber8696a8d2013-01-09 21:15:03 +00001937
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001938 if (FormatTok->Tok.is(tok::less))
Nico Weber8696a8d2013-01-09 21:15:03 +00001939 parseObjCProtocolList();
1940
1941 // Check for protocol declaration.
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00001942 if (FormatTok->Tok.is(tok::semi)) {
Nico Weber8696a8d2013-01-09 21:15:03 +00001943 nextToken();
1944 return addUnwrappedLine();
1945 }
1946
1947 addUnwrappedLine();
1948 parseObjCUntilAtEnd();
Nico Weber7eecf4b2013-01-09 20:25:35 +00001949}
1950
Daniel Jasperfca735c2015-02-19 16:14:18 +00001951void UnwrappedLineParser::parseJavaScriptEs6ImportExport() {
Martin Probst053f1aa2016-04-19 14:55:37 +00001952 bool IsImport = FormatTok->is(Keywords.kw_import);
1953 assert(IsImport || FormatTok->is(tok::kw_export));
Daniel Jasper354aa512015-02-19 16:07:32 +00001954 nextToken();
Daniel Jasperfca735c2015-02-19 16:14:18 +00001955
Daniel Jasperec05fc72015-05-11 09:14:50 +00001956 // Consume the "default" in "export default class/function".
Daniel Jasper668c7bb2015-05-11 09:03:10 +00001957 if (FormatTok->is(tok::kw_default))
1958 nextToken();
Daniel Jasperec05fc72015-05-11 09:14:50 +00001959
Martin Probst5f8445b2016-04-24 22:05:09 +00001960 // Consume "async function", "function" and "default function", so that these
1961 // get parsed as free-standing JS functions, i.e. do not require a trailing
1962 // semicolon.
1963 if (FormatTok->is(Keywords.kw_async))
1964 nextToken();
Daniel Jasper668c7bb2015-05-11 09:03:10 +00001965 if (FormatTok->is(Keywords.kw_function)) {
1966 nextToken();
1967 return;
1968 }
1969
Martin Probst053f1aa2016-04-19 14:55:37 +00001970 // For imports, `export *`, `export {...}`, consume the rest of the line up
1971 // to the terminating `;`. For everything else, just return and continue
1972 // parsing the structural element, i.e. the declaration or expression for
1973 // `export default`.
1974 if (!IsImport && !FormatTok->isOneOf(tok::l_brace, tok::star) &&
1975 !FormatTok->isStringLiteral())
1976 return;
Daniel Jasperfca735c2015-02-19 16:14:18 +00001977
Martin Probstd40bca42017-01-09 08:56:36 +00001978 while (!eof()) {
1979 if (FormatTok->is(tok::semi))
1980 return;
1981 if (Line->Tokens.size() == 0) {
1982 // Common issue: Automatic Semicolon Insertion wrapped the line, so the
1983 // import statement should terminate.
1984 return;
1985 }
Daniel Jasperefc1a832016-01-07 08:53:35 +00001986 if (FormatTok->is(tok::l_brace)) {
1987 FormatTok->BlockKind = BK_Block;
1988 parseBracedList();
1989 } else {
1990 nextToken();
1991 }
Daniel Jasper354aa512015-02-19 16:07:32 +00001992 }
1993}
1994
Daniel Jasper3b203a62013-09-05 16:05:56 +00001995LLVM_ATTRIBUTE_UNUSED static void printDebugInfo(const UnwrappedLine &Line,
1996 StringRef Prefix = "") {
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00001997 llvm::dbgs() << Prefix << "Line(" << Line.Level << ")"
1998 << (Line.InPPDirective ? " MACRO" : "") << ": ";
1999 for (std::list<UnwrappedLineNode>::const_iterator I = Line.Tokens.begin(),
2000 E = Line.Tokens.end();
2001 I != E; ++I) {
Daniel Jasper9a8d48b2013-09-05 10:04:31 +00002002 llvm::dbgs() << I->Tok->Tok.getName() << "[" << I->Tok->Type << "] ";
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00002003 }
2004 for (std::list<UnwrappedLineNode>::const_iterator I = Line.Tokens.begin(),
2005 E = Line.Tokens.end();
2006 I != E; ++I) {
2007 const UnwrappedLineNode &Node = *I;
2008 for (SmallVectorImpl<UnwrappedLine>::const_iterator
2009 I = Node.Children.begin(),
2010 E = Node.Children.end();
2011 I != E; ++I) {
2012 printDebugInfo(*I, "\nChild: ");
2013 }
2014 }
2015 llvm::dbgs() << "\n";
2016}
2017
Daniel Jasperf7935112012-12-03 18:12:45 +00002018void UnwrappedLineParser::addUnwrappedLine() {
Daniel Jasperdaffc0d2013-01-16 09:10:19 +00002019 if (Line->Tokens.empty())
Daniel Jasper7c85fde2013-01-08 14:56:18 +00002020 return;
Manuel Klimekab3dc002013-01-16 12:31:12 +00002021 DEBUG({
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00002022 if (CurrentLines == &Lines)
2023 printDebugInfo(*Line);
Manuel Klimekab3dc002013-01-16 12:31:12 +00002024 });
Benjamin Kramerc7551a42015-05-31 11:18:05 +00002025 CurrentLines->push_back(std::move(*Line));
Daniel Jasperdaffc0d2013-01-16 09:10:19 +00002026 Line->Tokens.clear();
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00002027 if (CurrentLines == &Lines && !PreprocessorDirectives.empty()) {
Benjamin Kramerc7551a42015-05-31 11:18:05 +00002028 CurrentLines->append(
2029 std::make_move_iterator(PreprocessorDirectives.begin()),
2030 std::make_move_iterator(PreprocessorDirectives.end()));
Manuel Klimekd3b92fa2013-01-18 14:04:34 +00002031 PreprocessorDirectives.clear();
2032 }
Daniel Jasperf7935112012-12-03 18:12:45 +00002033}
2034
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00002035bool UnwrappedLineParser::eof() const { return FormatTok->Tok.is(tok::eof); }
Daniel Jasperf7935112012-12-03 18:12:45 +00002036
Daniel Jasperb05a81d2014-05-09 13:11:16 +00002037bool UnwrappedLineParser::isOnNewLine(const FormatToken &FormatTok) {
Manuel Klimek1fcbe672014-04-11 12:27:47 +00002038 return (Line->InPPDirective || FormatTok.HasUnescapedNewline) &&
2039 FormatTok.NewlinesBefore > 0;
2040}
2041
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002042void UnwrappedLineParser::flushComments(bool NewlineBeforeNext) {
2043 bool JustComments = Line->Tokens.empty();
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00002044 for (SmallVectorImpl<FormatToken *>::const_iterator
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002045 I = CommentsBeforeNextToken.begin(),
2046 E = CommentsBeforeNextToken.end();
2047 I != E; ++I) {
Daniel Jaspere60cba12015-05-13 11:35:53 +00002048 if (isOnNewLine(**I) && JustComments)
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002049 addUnwrappedLine();
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002050 pushToken(*I);
2051 }
Daniel Jaspere60cba12015-05-13 11:35:53 +00002052 if (NewlineBeforeNext && JustComments)
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002053 addUnwrappedLine();
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002054 CommentsBeforeNextToken.clear();
2055}
2056
Daniel Jasperf7935112012-12-03 18:12:45 +00002057void UnwrappedLineParser::nextToken() {
2058 if (eof())
2059 return;
Manuel Klimek1fcbe672014-04-11 12:27:47 +00002060 flushComments(isOnNewLine(*FormatTok));
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002061 pushToken(FormatTok);
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00002062 if (Style.Language != FormatStyle::LK_JavaScript)
2063 readToken();
2064 else
2065 readTokenWithJavaScriptASI();
Manuel Klimek1abf7892013-01-04 23:34:14 +00002066}
2067
Daniel Jasperb9a49902016-01-09 15:56:28 +00002068const FormatToken *UnwrappedLineParser::getPreviousToken() {
2069 // FIXME: This is a dirty way to access the previous token. Find a better
2070 // solution.
2071 if (!Line || Line->Tokens.empty())
2072 return nullptr;
2073 return Line->Tokens.back().Tok;
2074}
2075
Manuel Klimek1abf7892013-01-04 23:34:14 +00002076void UnwrappedLineParser::readToken() {
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002077 bool CommentsInCurrentLine = true;
2078 do {
2079 FormatTok = Tokens->getNextToken();
Alexander Kornienkoc2ee9cf2014-03-13 13:59:48 +00002080 assert(FormatTok);
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00002081 while (!Line->InPPDirective && FormatTok->Tok.is(tok::hash) &&
2082 (FormatTok->HasUnescapedNewline || FormatTok->IsFirst)) {
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002083 // If there is an unfinished unwrapped line, we flush the preprocessor
2084 // directives only after that unwrapped line was finished later.
Daniel Jasper29d39d52015-02-08 09:34:49 +00002085 bool SwitchToPreprocessorLines = !Line->Tokens.empty();
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002086 ScopedLineState BlockState(*this, SwitchToPreprocessorLines);
Alexander Kornienkob1be9d62013-04-03 12:38:53 +00002087 // Comments stored before the preprocessor directive need to be output
2088 // before the preprocessor directive, at the same level as the
2089 // preprocessor directive, as we consider them to apply to the directive.
Manuel Klimek1fcbe672014-04-11 12:27:47 +00002090 flushComments(isOnNewLine(*FormatTok));
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002091 parsePPDirective();
2092 }
Manuel Klimek68b03042014-04-14 09:14:11 +00002093 while (FormatTok->Type == TT_ConflictStart ||
2094 FormatTok->Type == TT_ConflictEnd ||
2095 FormatTok->Type == TT_ConflictAlternative) {
2096 if (FormatTok->Type == TT_ConflictStart) {
2097 conditionalCompilationStart(/*Unreachable=*/false);
2098 } else if (FormatTok->Type == TT_ConflictAlternative) {
2099 conditionalCompilationAlternative();
Daniel Jasperb05a81d2014-05-09 13:11:16 +00002100 } else if (FormatTok->Type == TT_ConflictEnd) {
Manuel Klimek68b03042014-04-14 09:14:11 +00002101 conditionalCompilationEnd();
2102 }
2103 FormatTok = Tokens->getNextToken();
2104 FormatTok->MustBreakBefore = true;
2105 }
Alexander Kornienkof2e02122013-05-24 18:24:24 +00002106
2107 if (!PPStack.empty() && (PPStack.back() == PP_Unreachable) &&
2108 !Line->InPPDirective) {
2109 continue;
2110 }
2111
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00002112 if (!FormatTok->Tok.is(tok::comment))
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002113 return;
Manuel Klimek1fcbe672014-04-11 12:27:47 +00002114 if (isOnNewLine(*FormatTok) || FormatTok->IsFirst) {
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002115 CommentsInCurrentLine = false;
2116 }
2117 if (CommentsInCurrentLine) {
2118 pushToken(FormatTok);
2119 } else {
2120 CommentsBeforeNextToken.push_back(FormatTok);
2121 }
2122 } while (!eof());
2123}
2124
Manuel Klimek15dfe7a2013-05-28 11:55:06 +00002125void UnwrappedLineParser::pushToken(FormatToken *Tok) {
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00002126 Line->Tokens.push_back(UnwrappedLineNode(Tok));
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002127 if (MustBreakBeforeNextToken) {
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00002128 Line->Tokens.back().Tok->MustBreakBefore = true;
Manuel Klimekf92f7bc2013-01-22 16:31:55 +00002129 MustBreakBeforeNextToken = false;
Manuel Klimek1abf7892013-01-04 23:34:14 +00002130 }
Daniel Jasperf7935112012-12-03 18:12:45 +00002131}
2132
Daniel Jasper8d1832e2013-01-07 13:26:07 +00002133} // end namespace format
2134} // end namespace clang