blob: ee476b952e07fe1786ca331fd2432919e29fef6c [file] [log] [blame]
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001//===--- TokenAnnotator.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 implements a token annotator, i.e. creates
12/// \c AnnotatedTokens out of \c FormatTokens with required extra information.
13///
14//===----------------------------------------------------------------------===//
15
16#include "TokenAnnotator.h"
17#include "clang/Basic/SourceManager.h"
Daniel Jasperbf71ba22013-04-08 20:33:42 +000018#include "llvm/Support/Debug.h"
Daniel Jasper32d28ee2013-01-29 21:01:14 +000019
20namespace clang {
21namespace format {
22
Craig Topper14e66492013-07-01 04:03:19 +000023namespace {
24
Daniel Jasper32d28ee2013-01-29 21:01:14 +000025/// \brief A parser that gathers additional information about tokens.
26///
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +000027/// The \c TokenAnnotator tries to match parenthesis and square brakets and
Daniel Jasper32d28ee2013-01-29 21:01:14 +000028/// store a parenthesis levels. It also tries to resolve matching "<" and ">"
29/// into template parameter lists.
30class AnnotatingParser {
31public:
Daniel Jasperd4a03db2013-08-22 15:00:41 +000032 AnnotatingParser(const FormatStyle &Style, AnnotatedLine &Line,
33 IdentifierInfo &Ident_in)
34 : Style(Style), Line(Line), CurrentToken(Line.First),
35 KeywordVirtualFound(false), NameFound(false), AutoFound(false),
36 Ident_in(Ident_in) {
Nico Weber27268772013-06-26 00:30:14 +000037 Contexts.push_back(Context(tok::unknown, 1, /*IsExpression=*/false));
Daniel Jasper32d28ee2013-01-29 21:01:14 +000038 }
39
Nico Weber95e8e462013-02-12 16:17:07 +000040private:
Daniel Jasper32d28ee2013-01-29 21:01:14 +000041 bool parseAngle() {
42 if (CurrentToken == NULL)
43 return false;
Daniel Jasper923ebef2013-03-14 13:45:21 +000044 ScopedContextCreator ContextCreator(*this, tok::less, 10);
Manuel Klimekb3987012013-05-29 14:47:47 +000045 FormatToken *Left = CurrentToken->Previous;
Daniel Jasper4e778092013-02-06 10:05:46 +000046 Contexts.back().IsExpression = false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +000047 while (CurrentToken != NULL) {
48 if (CurrentToken->is(tok::greater)) {
49 Left->MatchingParen = CurrentToken;
50 CurrentToken->MatchingParen = Left;
51 CurrentToken->Type = TT_TemplateCloser;
52 next();
53 return true;
54 }
Alexander Kornienkoe74de282013-03-13 14:41:29 +000055 if (CurrentToken->isOneOf(tok::r_paren, tok::r_square, tok::r_brace,
Daniel Jasper5d823e32013-05-15 13:46:48 +000056 tok::question, tok::colon))
57 return false;
Daniel Jasper0348be02013-06-01 18:56:00 +000058 // If a && or || is found and interpreted as a binary operator, this set
Daniel Jasper15f33f02013-06-03 16:16:41 +000059 // of angles is likely part of something like "a < b && c > d". If the
Daniel Jasper0348be02013-06-01 18:56:00 +000060 // angles are inside an expression, the ||/&& might also be a binary
61 // operator that was misinterpreted because we are parsing template
62 // parameters.
63 // FIXME: This is getting out of hand, write a decent parser.
Manuel Klimekb3987012013-05-29 14:47:47 +000064 if (CurrentToken->Previous->isOneOf(tok::pipepipe, tok::ampamp) &&
Daniel Jasper0348be02013-06-01 18:56:00 +000065 (CurrentToken->Previous->Type == TT_BinaryOperator ||
66 Contexts[Contexts.size() - 2].IsExpression) &&
Manuel Klimekb3987012013-05-29 14:47:47 +000067 Line.First->isNot(tok::kw_template))
Daniel Jasper32d28ee2013-01-29 21:01:14 +000068 return false;
Daniel Jasper9fc56f22013-02-14 15:01:34 +000069 updateParameterCount(Left, CurrentToken);
Daniel Jasper32d28ee2013-01-29 21:01:14 +000070 if (!consumeToken())
71 return false;
72 }
73 return false;
74 }
75
76 bool parseParens(bool LookForDecls = false) {
77 if (CurrentToken == NULL)
78 return false;
Daniel Jasper923ebef2013-03-14 13:45:21 +000079 ScopedContextCreator ContextCreator(*this, tok::l_paren, 1);
Daniel Jasper4e778092013-02-06 10:05:46 +000080
81 // FIXME: This is a bit of a hack. Do better.
82 Contexts.back().ColonIsForRangeExpr =
83 Contexts.size() == 2 && Contexts[0].ColonIsForRangeExpr;
84
Daniel Jasper32d28ee2013-01-29 21:01:14 +000085 bool StartsObjCMethodExpr = false;
Manuel Klimekb3987012013-05-29 14:47:47 +000086 FormatToken *Left = CurrentToken->Previous;
Daniel Jasper32d28ee2013-01-29 21:01:14 +000087 if (CurrentToken->is(tok::caret)) {
88 // ^( starts a block.
89 Left->Type = TT_ObjCBlockLParen;
Manuel Klimekb3987012013-05-29 14:47:47 +000090 } else if (FormatToken *MaybeSel = Left->Previous) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +000091 // @selector( starts a selector.
Manuel Klimekb3987012013-05-29 14:47:47 +000092 if (MaybeSel->isObjCAtKeyword(tok::objc_selector) && MaybeSel->Previous &&
93 MaybeSel->Previous->is(tok::at)) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +000094 StartsObjCMethodExpr = true;
95 }
96 }
97
Daniel Jasperb644dd62013-08-13 09:09:09 +000098 if (Left->Previous && Left->Previous->isOneOf(tok::kw_static_assert,
99 tok::kw_if, tok::kw_while))
Daniel Jasperb7000ca2013-08-01 17:58:23 +0000100 Contexts.back().IsExpression = true;
101
Daniel Jasper4e778092013-02-06 10:05:46 +0000102 if (StartsObjCMethodExpr) {
103 Contexts.back().ColonIsObjCMethodExpr = true;
104 Left->Type = TT_ObjCMethodExpr;
105 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000106
Daniel Jasper431f5912013-05-28 08:33:00 +0000107 bool MightBeFunctionType = CurrentToken->is(tok::star);
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000108 bool HasMultipleLines = false;
109 bool HasMultipleParametersOnALine = false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000110 while (CurrentToken != NULL) {
111 // LookForDecls is set when "if (" has been seen. Check for
112 // 'identifier' '*' 'identifier' followed by not '=' -- this
113 // '*' has to be a binary operator but determineStarAmpUsage() will
114 // categorize it as an unary operator, so set the right type here.
Manuel Klimekb3987012013-05-29 14:47:47 +0000115 if (LookForDecls && CurrentToken->Next) {
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000116 FormatToken *Prev = CurrentToken->getPreviousNonComment();
Alexander Kornienko2785b9a2013-06-07 16:02:52 +0000117 if (Prev) {
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000118 FormatToken *PrevPrev = Prev->getPreviousNonComment();
Alexander Kornienko2785b9a2013-06-07 16:02:52 +0000119 FormatToken *Next = CurrentToken->Next;
120 if (PrevPrev && PrevPrev->is(tok::identifier) &&
121 Prev->isOneOf(tok::star, tok::amp, tok::ampamp) &&
122 CurrentToken->is(tok::identifier) && Next->isNot(tok::equal)) {
123 Prev->Type = TT_BinaryOperator;
124 LookForDecls = false;
125 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000126 }
127 }
128
Daniel Jasper53352602013-08-12 12:16:34 +0000129 if (CurrentToken->Previous->Type == TT_PointerOrReference &&
130 CurrentToken->Previous->Previous->isOneOf(tok::l_paren,
131 tok::coloncolon))
132 MightBeFunctionType = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000133 if (CurrentToken->is(tok::r_paren)) {
Manuel Klimekb3987012013-05-29 14:47:47 +0000134 if (MightBeFunctionType && CurrentToken->Next &&
Daniel Jaspere7d3bff2013-07-16 11:37:21 +0000135 (CurrentToken->Next->is(tok::l_paren) ||
136 (CurrentToken->Next->is(tok::l_square) &&
137 !Contexts.back().IsExpression)))
Daniel Jasper431f5912013-05-28 08:33:00 +0000138 Left->Type = TT_FunctionTypeLParen;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000139 Left->MatchingParen = CurrentToken;
140 CurrentToken->MatchingParen = Left;
141
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000142 if (StartsObjCMethodExpr) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000143 CurrentToken->Type = TT_ObjCMethodExpr;
144 if (Contexts.back().FirstObjCSelectorName != NULL) {
145 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
146 Contexts.back().LongestObjCSelectorName;
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000147 }
148 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000149
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000150 if (!HasMultipleLines)
151 Left->PackingKind = PPK_Inconclusive;
152 else if (HasMultipleParametersOnALine)
153 Left->PackingKind = PPK_BinPacked;
154 else
155 Left->PackingKind = PPK_OnePerLine;
156
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000157 next();
158 return true;
159 }
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000160 if (CurrentToken->isOneOf(tok::r_square, tok::r_brace))
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000161 return false;
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000162 updateParameterCount(Left, CurrentToken);
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000163 if (CurrentToken->is(tok::comma) && CurrentToken->Next &&
164 !CurrentToken->Next->HasUnescapedNewline &&
165 !CurrentToken->Next->isTrailingComment())
166 HasMultipleParametersOnALine = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000167 if (!consumeToken())
168 return false;
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000169 if (CurrentToken && CurrentToken->HasUnescapedNewline)
170 HasMultipleLines = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000171 }
172 return false;
173 }
174
175 bool parseSquare() {
176 if (!CurrentToken)
177 return false;
178
Alexander Kornienkod71b15b2013-06-17 13:19:53 +0000179 // A '[' could be an index subscript (after an identifier or after
Nico Weber051860e2013-02-10 02:08:05 +0000180 // ')' or ']'), it could be the start of an Objective-C method
181 // expression, or it could the the start of an Objective-C array literal.
Manuel Klimekb3987012013-05-29 14:47:47 +0000182 FormatToken *Left = CurrentToken->Previous;
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000183 FormatToken *Parent = Left->getPreviousNonComment();
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000184 bool StartsObjCMethodExpr =
Daniel Jasper6f21a982013-03-13 07:49:51 +0000185 Contexts.back().CanBeExpression &&
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000186 (!Parent || Parent->isOneOf(tok::colon, tok::l_square, tok::l_paren,
187 tok::kw_return, tok::kw_throw) ||
Daniel Jasperac3223e2013-04-10 09:49:49 +0000188 Parent->isUnaryOperator() || Parent->Type == TT_ObjCForIn ||
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000189 Parent->Type == TT_CastRParen ||
Manuel Klimekb3987012013-05-29 14:47:47 +0000190 getBinOpPrecedence(Parent->Tok.getKind(), true, true) > prec::Unknown);
Daniel Jasper923ebef2013-03-14 13:45:21 +0000191 ScopedContextCreator ContextCreator(*this, tok::l_square, 10);
Daniel Jasper6f21a982013-03-13 07:49:51 +0000192 Contexts.back().IsExpression = true;
Nico Weber051860e2013-02-10 02:08:05 +0000193 bool StartsObjCArrayLiteral = Parent && Parent->is(tok::at);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000194
Daniel Jasper4e778092013-02-06 10:05:46 +0000195 if (StartsObjCMethodExpr) {
196 Contexts.back().ColonIsObjCMethodExpr = true;
197 Left->Type = TT_ObjCMethodExpr;
Nico Weber051860e2013-02-10 02:08:05 +0000198 } else if (StartsObjCArrayLiteral) {
199 Left->Type = TT_ObjCArrayLiteral;
Daniel Jasper4e778092013-02-06 10:05:46 +0000200 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000201
202 while (CurrentToken != NULL) {
203 if (CurrentToken->is(tok::r_square)) {
Manuel Klimekb3987012013-05-29 14:47:47 +0000204 if (CurrentToken->Next && CurrentToken->Next->is(tok::l_paren)) {
Nico Webere8a97982013-02-06 06:20:11 +0000205 // An ObjC method call is rarely followed by an open parenthesis.
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000206 // FIXME: Do we incorrectly label ":" with this?
207 StartsObjCMethodExpr = false;
208 Left->Type = TT_Unknown;
209 }
Daniel Jasper01786732013-02-04 07:21:18 +0000210 if (StartsObjCMethodExpr) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000211 CurrentToken->Type = TT_ObjCMethodExpr;
Nico Webere8a97982013-02-06 06:20:11 +0000212 // determineStarAmpUsage() thinks that '*' '[' is allocating an
213 // array of pointers, but if '[' starts a selector then '*' is a
214 // binary operator.
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +0000215 if (Parent != NULL && Parent->Type == TT_PointerOrReference)
Nico Weber4ed7f3e2013-02-06 16:54:35 +0000216 Parent->Type = TT_BinaryOperator;
Nico Weber051860e2013-02-10 02:08:05 +0000217 } else if (StartsObjCArrayLiteral) {
218 CurrentToken->Type = TT_ObjCArrayLiteral;
Daniel Jasper01786732013-02-04 07:21:18 +0000219 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000220 Left->MatchingParen = CurrentToken;
221 CurrentToken->MatchingParen = Left;
Daniel Jasper4e778092013-02-06 10:05:46 +0000222 if (Contexts.back().FirstObjCSelectorName != NULL)
223 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
224 Contexts.back().LongestObjCSelectorName;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000225 next();
226 return true;
227 }
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000228 if (CurrentToken->isOneOf(tok::r_paren, tok::r_brace))
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000229 return false;
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000230 updateParameterCount(Left, CurrentToken);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000231 if (!consumeToken())
232 return false;
233 }
234 return false;
235 }
236
237 bool parseBrace() {
Daniel Jasper53e72cd2013-05-06 08:27:33 +0000238 if (CurrentToken != NULL) {
239 ScopedContextCreator ContextCreator(*this, tok::l_brace, 1);
Manuel Klimekb3987012013-05-29 14:47:47 +0000240 FormatToken *Left = CurrentToken->Previous;
Nico Weberf2ff8122013-05-26 05:39:26 +0000241
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000242 FormatToken *Parent = Left->getPreviousNonComment();
Nico Weberf2ff8122013-05-26 05:39:26 +0000243 bool StartsObjCDictLiteral = Parent && Parent->is(tok::at);
244 if (StartsObjCDictLiteral) {
245 Contexts.back().ColonIsObjCDictLiteral = true;
246 Left->Type = TT_ObjCDictLiteral;
247 }
248
Daniel Jasper53e72cd2013-05-06 08:27:33 +0000249 while (CurrentToken != NULL) {
250 if (CurrentToken->is(tok::r_brace)) {
Nico Weberf2ff8122013-05-26 05:39:26 +0000251 if (StartsObjCDictLiteral)
252 CurrentToken->Type = TT_ObjCDictLiteral;
Daniel Jasper53e72cd2013-05-06 08:27:33 +0000253 Left->MatchingParen = CurrentToken;
254 CurrentToken->MatchingParen = Left;
255 next();
256 return true;
257 }
258 if (CurrentToken->isOneOf(tok::r_paren, tok::r_square))
259 return false;
260 updateParameterCount(Left, CurrentToken);
261 if (!consumeToken())
262 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000263 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000264 }
Daniel Jasper53e72cd2013-05-06 08:27:33 +0000265 // No closing "}" found, this probably starts a definition.
266 Line.StartsDefinition = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000267 return true;
268 }
Daniel Jasperc4615b72013-02-20 12:56:39 +0000269
Manuel Klimekb3987012013-05-29 14:47:47 +0000270 void updateParameterCount(FormatToken *Left, FormatToken *Current) {
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000271 if (Current->is(tok::comma)) {
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000272 ++Left->ParameterCount;
Daniel Jasperd4a03db2013-08-22 15:00:41 +0000273 if (!Left->Role)
274 Left->Role.reset(new CommaSeparatedList(Style));
275 Left->Role->CommaFound(Current);
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000276 } else if (Left->ParameterCount == 0 && Current->isNot(tok::comment)) {
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000277 Left->ParameterCount = 1;
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000278 }
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000279 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000280
281 bool parseConditional() {
282 while (CurrentToken != NULL) {
283 if (CurrentToken->is(tok::colon)) {
284 CurrentToken->Type = TT_ConditionalExpr;
285 next();
286 return true;
287 }
288 if (!consumeToken())
289 return false;
290 }
291 return false;
292 }
293
294 bool parseTemplateDeclaration() {
295 if (CurrentToken != NULL && CurrentToken->is(tok::less)) {
296 CurrentToken->Type = TT_TemplateOpener;
297 next();
298 if (!parseAngle())
299 return false;
Daniel Jasper34511fb2013-02-19 17:14:38 +0000300 if (CurrentToken != NULL)
Manuel Klimekb3987012013-05-29 14:47:47 +0000301 CurrentToken->Previous->ClosesTemplateDeclaration = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000302 return true;
303 }
304 return false;
305 }
306
307 bool consumeToken() {
Manuel Klimekb3987012013-05-29 14:47:47 +0000308 FormatToken *Tok = CurrentToken;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000309 next();
Manuel Klimekb3987012013-05-29 14:47:47 +0000310 switch (Tok->Tok.getKind()) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000311 case tok::plus:
312 case tok::minus:
Manuel Klimekb3987012013-05-29 14:47:47 +0000313 if (Tok->Previous == NULL && Line.MustBeDeclaration)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000314 Tok->Type = TT_ObjCMethodSpecifier;
315 break;
316 case tok::colon:
Manuel Klimekb3987012013-05-29 14:47:47 +0000317 if (Tok->Previous == NULL)
Daniel Jaspercf6d76a2013-03-18 12:50:26 +0000318 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000319 // Colons from ?: are handled in parseConditional().
Manuel Klimekb3987012013-05-29 14:47:47 +0000320 if (Tok->Previous->is(tok::r_paren) && Contexts.size() == 1) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000321 Tok->Type = TT_CtorInitializerColon;
Nico Weberf2ff8122013-05-26 05:39:26 +0000322 } else if (Contexts.back().ColonIsObjCDictLiteral) {
323 Tok->Type = TT_ObjCDictLiteral;
Daniel Jasper4e778092013-02-06 10:05:46 +0000324 } else if (Contexts.back().ColonIsObjCMethodExpr ||
Manuel Klimekb3987012013-05-29 14:47:47 +0000325 Line.First->Type == TT_ObjCMethodSpecifier) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000326 Tok->Type = TT_ObjCMethodExpr;
Manuel Klimekb3987012013-05-29 14:47:47 +0000327 Tok->Previous->Type = TT_ObjCSelectorName;
Alexander Kornienko00895102013-06-05 14:09:10 +0000328 if (Tok->Previous->CodePointCount >
329 Contexts.back().LongestObjCSelectorName) {
330 Contexts.back().LongestObjCSelectorName =
331 Tok->Previous->CodePointCount;
332 }
Daniel Jasper4e778092013-02-06 10:05:46 +0000333 if (Contexts.back().FirstObjCSelectorName == NULL)
Manuel Klimekb3987012013-05-29 14:47:47 +0000334 Contexts.back().FirstObjCSelectorName = Tok->Previous;
Daniel Jasper4e778092013-02-06 10:05:46 +0000335 } else if (Contexts.back().ColonIsForRangeExpr) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000336 Tok->Type = TT_RangeBasedForLoopColon;
Daniel Jasper6cabab42013-02-14 08:42:54 +0000337 } else if (Contexts.size() == 1) {
338 Tok->Type = TT_InheritanceColon;
Daniel Jasper923ebef2013-03-14 13:45:21 +0000339 } else if (Contexts.back().ContextKind == tok::l_paren) {
340 Tok->Type = TT_InlineASMColon;
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000341 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000342 break;
343 case tok::kw_if:
344 case tok::kw_while:
345 if (CurrentToken != NULL && CurrentToken->is(tok::l_paren)) {
346 next();
Nico Weber27268772013-06-26 00:30:14 +0000347 if (!parseParens(/*LookForDecls=*/true))
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000348 return false;
349 }
350 break;
351 case tok::kw_for:
Daniel Jasper4e778092013-02-06 10:05:46 +0000352 Contexts.back().ColonIsForRangeExpr = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000353 next();
354 if (!parseParens())
355 return false;
356 break;
357 case tok::l_paren:
358 if (!parseParens())
359 return false;
Daniel Jasper1407bee2013-04-11 14:29:13 +0000360 if (Line.MustBeDeclaration && NameFound && !Contexts.back().IsExpression)
Daniel Jasper3c08a812013-02-24 18:54:32 +0000361 Line.MightBeFunctionDecl = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000362 break;
363 case tok::l_square:
364 if (!parseSquare())
365 return false;
366 break;
367 case tok::l_brace:
368 if (!parseBrace())
369 return false;
370 break;
371 case tok::less:
Daniel Jasper0236dd02013-07-30 22:37:19 +0000372 if (Tok->Previous && !Tok->Previous->Tok.isLiteral() && parseAngle())
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000373 Tok->Type = TT_TemplateOpener;
374 else {
375 Tok->Type = TT_BinaryOperator;
376 CurrentToken = Tok;
377 next();
378 }
379 break;
380 case tok::r_paren:
381 case tok::r_square:
382 return false;
383 case tok::r_brace:
384 // Lines can start with '}'.
Manuel Klimekb3987012013-05-29 14:47:47 +0000385 if (Tok->Previous != NULL)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000386 return false;
387 break;
388 case tok::greater:
389 Tok->Type = TT_BinaryOperator;
390 break;
391 case tok::kw_operator:
Daniel Jasper2b4c9242013-02-11 08:01:18 +0000392 while (CurrentToken && CurrentToken->isNot(tok::l_paren)) {
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000393 if (CurrentToken->isOneOf(tok::star, tok::amp))
Daniel Jasper2b4c9242013-02-11 08:01:18 +0000394 CurrentToken->Type = TT_PointerOrReference;
395 consumeToken();
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000396 }
Daniel Jasper6ea933c2013-05-10 07:59:58 +0000397 if (CurrentToken) {
Daniel Jasper2b4c9242013-02-11 08:01:18 +0000398 CurrentToken->Type = TT_OverloadedOperatorLParen;
Manuel Klimekb3987012013-05-29 14:47:47 +0000399 if (CurrentToken->Previous->Type == TT_BinaryOperator)
400 CurrentToken->Previous->Type = TT_OverloadedOperator;
Daniel Jasper6ea933c2013-05-10 07:59:58 +0000401 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000402 break;
403 case tok::question:
404 parseConditional();
405 break;
406 case tok::kw_template:
407 parseTemplateDeclaration();
408 break;
Nico Weberc2e6d2a2013-02-11 15:32:15 +0000409 case tok::identifier:
Manuel Klimekb3987012013-05-29 14:47:47 +0000410 if (Line.First->is(tok::kw_for) &&
411 Tok->Tok.getIdentifierInfo() == &Ident_in)
Nico Weberc2e6d2a2013-02-11 15:32:15 +0000412 Tok->Type = TT_ObjCForIn;
413 break;
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000414 case tok::comma:
415 if (Contexts.back().FirstStartOfName)
416 Contexts.back().FirstStartOfName->PartOfMultiVariableDeclStmt = true;
Daniel Jaspere8b10d32013-07-26 16:56:36 +0000417 if (Contexts.back().InCtorInitializer)
418 Tok->Type = TT_CtorInitializerComma;
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000419 break;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000420 default:
421 break;
422 }
423 return true;
424 }
425
426 void parseIncludeDirective() {
427 next();
428 if (CurrentToken != NULL && CurrentToken->is(tok::less)) {
429 next();
430 while (CurrentToken != NULL) {
Manuel Klimekb3987012013-05-29 14:47:47 +0000431 if (CurrentToken->isNot(tok::comment) || CurrentToken->Next)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000432 CurrentToken->Type = TT_ImplicitStringLiteral;
433 next();
434 }
435 } else {
436 while (CurrentToken != NULL) {
Daniel Jasper3a204412013-02-23 07:46:38 +0000437 if (CurrentToken->is(tok::string_literal))
438 // Mark these string literals as "implicit" literals, too, so that
439 // they are not split or line-wrapped.
440 CurrentToken->Type = TT_ImplicitStringLiteral;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000441 next();
442 }
443 }
444 }
445
446 void parseWarningOrError() {
447 next();
448 // We still want to format the whitespace left of the first token of the
449 // warning or error.
450 next();
451 while (CurrentToken != NULL) {
452 CurrentToken->Type = TT_ImplicitStringLiteral;
453 next();
454 }
455 }
456
457 void parsePreprocessorDirective() {
458 next();
459 if (CurrentToken == NULL)
460 return;
461 // Hashes in the middle of a line can lead to any strange token
462 // sequence.
Manuel Klimekb3987012013-05-29 14:47:47 +0000463 if (CurrentToken->Tok.getIdentifierInfo() == NULL)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000464 return;
Manuel Klimekb3987012013-05-29 14:47:47 +0000465 switch (CurrentToken->Tok.getIdentifierInfo()->getPPKeywordID()) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000466 case tok::pp_include:
467 case tok::pp_import:
468 parseIncludeDirective();
469 break;
470 case tok::pp_error:
471 case tok::pp_warning:
472 parseWarningOrError();
473 break;
Daniel Jasperaae7bad2013-04-23 13:54:04 +0000474 case tok::pp_if:
475 case tok::pp_elif:
476 parseLine();
477 break;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000478 default:
479 break;
480 }
Daniel Jasper5b7e7b02013-02-05 09:34:14 +0000481 while (CurrentToken != NULL)
482 next();
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000483 }
484
Nico Weber95e8e462013-02-12 16:17:07 +0000485public:
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000486 LineType parseLine() {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000487 if (CurrentToken->is(tok::hash)) {
488 parsePreprocessorDirective();
489 return LT_PreprocessorDirective;
490 }
491 while (CurrentToken != NULL) {
492 if (CurrentToken->is(tok::kw_virtual))
493 KeywordVirtualFound = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000494 if (!consumeToken())
495 return LT_Invalid;
496 }
497 if (KeywordVirtualFound)
498 return LT_VirtualFunctionDecl;
499
Manuel Klimekb3987012013-05-29 14:47:47 +0000500 if (Line.First->Type == TT_ObjCMethodSpecifier) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000501 if (Contexts.back().FirstObjCSelectorName != NULL)
502 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
503 Contexts.back().LongestObjCSelectorName;
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000504 return LT_ObjCMethodDecl;
505 }
506
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000507 return LT_Other;
508 }
509
Nico Weber95e8e462013-02-12 16:17:07 +0000510private:
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000511 void next() {
Daniel Jasper01786732013-02-04 07:21:18 +0000512 if (CurrentToken != NULL) {
513 determineTokenType(*CurrentToken);
Daniel Jasper4e778092013-02-06 10:05:46 +0000514 CurrentToken->BindingStrength = Contexts.back().BindingStrength;
Daniel Jasper01786732013-02-04 07:21:18 +0000515 }
516
Manuel Klimekb3987012013-05-29 14:47:47 +0000517 if (CurrentToken != NULL)
518 CurrentToken = CurrentToken->Next;
Daniel Jasperd0f349b2013-02-18 12:44:35 +0000519
520 // Reset token type in case we have already looked at it and then recovered
521 // from an error (e.g. failure to find the matching >).
522 if (CurrentToken != NULL)
523 CurrentToken->Type = TT_Unknown;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000524 }
525
Daniel Jasper4e778092013-02-06 10:05:46 +0000526 /// \brief A struct to hold information valid in a specific context, e.g.
527 /// a pair of parenthesis.
528 struct Context {
Daniel Jasper923ebef2013-03-14 13:45:21 +0000529 Context(tok::TokenKind ContextKind, unsigned BindingStrength,
530 bool IsExpression)
531 : ContextKind(ContextKind), BindingStrength(BindingStrength),
532 LongestObjCSelectorName(0), ColonIsForRangeExpr(false),
Nico Weberf2ff8122013-05-26 05:39:26 +0000533 ColonIsObjCDictLiteral(false), ColonIsObjCMethodExpr(false),
534 FirstObjCSelectorName(NULL), FirstStartOfName(NULL),
Daniel Jaspere8b10d32013-07-26 16:56:36 +0000535 IsExpression(IsExpression), CanBeExpression(true),
536 InCtorInitializer(false) {}
Daniel Jasper01786732013-02-04 07:21:18 +0000537
Daniel Jasper923ebef2013-03-14 13:45:21 +0000538 tok::TokenKind ContextKind;
Daniel Jasper4e778092013-02-06 10:05:46 +0000539 unsigned BindingStrength;
540 unsigned LongestObjCSelectorName;
541 bool ColonIsForRangeExpr;
Nico Weberf2ff8122013-05-26 05:39:26 +0000542 bool ColonIsObjCDictLiteral;
Daniel Jasper4e778092013-02-06 10:05:46 +0000543 bool ColonIsObjCMethodExpr;
Manuel Klimekb3987012013-05-29 14:47:47 +0000544 FormatToken *FirstObjCSelectorName;
545 FormatToken *FirstStartOfName;
Daniel Jasper4e778092013-02-06 10:05:46 +0000546 bool IsExpression;
Daniel Jasper6f21a982013-03-13 07:49:51 +0000547 bool CanBeExpression;
Daniel Jaspere8b10d32013-07-26 16:56:36 +0000548 bool InCtorInitializer;
Daniel Jasper4e778092013-02-06 10:05:46 +0000549 };
550
551 /// \brief Puts a new \c Context onto the stack \c Contexts for the lifetime
552 /// of each instance.
553 struct ScopedContextCreator {
554 AnnotatingParser &P;
555
Daniel Jasper923ebef2013-03-14 13:45:21 +0000556 ScopedContextCreator(AnnotatingParser &P, tok::TokenKind ContextKind,
557 unsigned Increase)
558 : P(P) {
Daniel Jasper2a409b62013-07-08 14:34:09 +0000559 P.Contexts.push_back(Context(ContextKind,
560 P.Contexts.back().BindingStrength + Increase,
561 P.Contexts.back().IsExpression));
Daniel Jasper4e778092013-02-06 10:05:46 +0000562 }
563
564 ~ScopedContextCreator() { P.Contexts.pop_back(); }
565 };
Daniel Jasper01786732013-02-04 07:21:18 +0000566
Manuel Klimekb3987012013-05-29 14:47:47 +0000567 void determineTokenType(FormatToken &Current) {
568 if (Current.getPrecedence() == prec::Assignment &&
Daniel Jasper53352602013-08-12 12:16:34 +0000569 !Line.First->isOneOf(tok::kw_template, tok::kw_using) &&
Manuel Klimekb3987012013-05-29 14:47:47 +0000570 (!Current.Previous || Current.Previous->isNot(tok::kw_operator))) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000571 Contexts.back().IsExpression = true;
Manuel Klimekb3987012013-05-29 14:47:47 +0000572 for (FormatToken *Previous = Current.Previous;
Nico Weber95e8e462013-02-12 16:17:07 +0000573 Previous && Previous->isNot(tok::comma);
Manuel Klimekb3987012013-05-29 14:47:47 +0000574 Previous = Previous->Previous) {
Daniel Jasper9c65b062013-02-27 11:43:50 +0000575 if (Previous->is(tok::r_square))
576 Previous = Previous->MatchingParen;
Daniel Jasper01786732013-02-04 07:21:18 +0000577 if (Previous->Type == TT_BinaryOperator &&
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000578 Previous->isOneOf(tok::star, tok::amp)) {
Daniel Jasper01786732013-02-04 07:21:18 +0000579 Previous->Type = TT_PointerOrReference;
580 }
Daniel Jasper01786732013-02-04 07:21:18 +0000581 }
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000582 } else if (Current.isOneOf(tok::kw_return, tok::kw_throw) ||
Nico Weber95e8e462013-02-12 16:17:07 +0000583 (Current.is(tok::l_paren) && !Line.MustBeDeclaration &&
Daniel Jasper378d93d2013-05-13 07:14:40 +0000584 !Line.InPPDirective &&
Manuel Klimek2530fd52013-08-12 03:51:17 +0000585 (!Current.Previous ||
Daniel Jasper53352602013-08-12 12:16:34 +0000586 !Current.Previous->isOneOf(tok::kw_for, tok::kw_catch)))) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000587 Contexts.back().IsExpression = true;
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000588 } else if (Current.isOneOf(tok::r_paren, tok::greater, tok::comma)) {
Manuel Klimekb3987012013-05-29 14:47:47 +0000589 for (FormatToken *Previous = Current.Previous;
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000590 Previous && Previous->isOneOf(tok::star, tok::amp);
Manuel Klimekb3987012013-05-29 14:47:47 +0000591 Previous = Previous->Previous)
Nico Weber95e8e462013-02-12 16:17:07 +0000592 Previous->Type = TT_PointerOrReference;
Manuel Klimekb3987012013-05-29 14:47:47 +0000593 } else if (Current.Previous &&
594 Current.Previous->Type == TT_CtorInitializerColon) {
Daniel Jasperd0f349b2013-02-18 12:44:35 +0000595 Contexts.back().IsExpression = true;
Daniel Jaspere8b10d32013-07-26 16:56:36 +0000596 Contexts.back().InCtorInitializer = true;
Daniel Jasper6f21a982013-03-13 07:49:51 +0000597 } else if (Current.is(tok::kw_new)) {
598 Contexts.back().CanBeExpression = false;
Daniel Jasper16a69ef2013-05-03 14:41:24 +0000599 } else if (Current.is(tok::semi)) {
600 // This should be the condition or increment in a for-loop.
601 Contexts.back().IsExpression = true;
Nico Weber95e8e462013-02-12 16:17:07 +0000602 }
Daniel Jasper01786732013-02-04 07:21:18 +0000603
604 if (Current.Type == TT_Unknown) {
Daniel Jasper6ac431c2013-07-02 09:47:29 +0000605 if (isStartOfName(Current)) {
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000606 Contexts.back().FirstStartOfName = &Current;
Daniel Jasper3c08a812013-02-24 18:54:32 +0000607 Current.Type = TT_StartOfName;
Daniel Jasper1407bee2013-04-11 14:29:13 +0000608 NameFound = true;
Daniel Jasper2ca37412013-07-09 14:36:48 +0000609 } else if (Current.is(tok::kw_auto)) {
610 AutoFound = true;
Daniel Jasper3262f4c2013-07-11 14:33:06 +0000611 } else if (Current.is(tok::arrow) && AutoFound &&
612 Line.MustBeDeclaration) {
Daniel Jasper2ca37412013-07-09 14:36:48 +0000613 Current.Type = TT_TrailingReturnArrow;
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000614 } else if (Current.isOneOf(tok::star, tok::amp, tok::ampamp)) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000615 Current.Type =
Daniel Jasperd6104f62013-07-05 13:30:40 +0000616 determineStarAmpUsage(Current, Contexts.back().CanBeExpression &&
617 Contexts.back().IsExpression);
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000618 } else if (Current.isOneOf(tok::minus, tok::plus, tok::caret)) {
Daniel Jasper01786732013-02-04 07:21:18 +0000619 Current.Type = determinePlusMinusCaretUsage(Current);
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000620 } else if (Current.isOneOf(tok::minusminus, tok::plusplus)) {
Daniel Jasper01786732013-02-04 07:21:18 +0000621 Current.Type = determineIncrementUsage(Current);
622 } else if (Current.is(tok::exclaim)) {
623 Current.Type = TT_UnaryOperator;
Daniel Jasperac3223e2013-04-10 09:49:49 +0000624 } else if (Current.isBinaryOperator()) {
Daniel Jasper01786732013-02-04 07:21:18 +0000625 Current.Type = TT_BinaryOperator;
626 } else if (Current.is(tok::comment)) {
Alexander Kornienko00895102013-06-05 14:09:10 +0000627 if (Current.TokenText.startswith("//"))
Daniel Jasper01786732013-02-04 07:21:18 +0000628 Current.Type = TT_LineComment;
629 else
630 Current.Type = TT_BlockComment;
Nico Weber37d69312013-02-13 04:13:13 +0000631 } else if (Current.is(tok::r_paren)) {
Daniel Jasperb8b42952013-05-31 16:14:28 +0000632 FormatToken *LeftOfParens = NULL;
633 if (Current.MatchingParen)
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000634 LeftOfParens = Current.MatchingParen->getPreviousNonComment();
Daniel Jasperb8b42952013-05-31 16:14:28 +0000635 bool IsCast = false;
636 bool ParensAreEmpty = Current.Previous == Current.MatchingParen;
637 bool ParensAreType = !Current.Previous ||
Manuel Klimekb3987012013-05-29 14:47:47 +0000638 Current.Previous->Type == TT_PointerOrReference ||
Daniel Jasperb8b42952013-05-31 16:14:28 +0000639 Current.Previous->Type == TT_TemplateCloser ||
640 isSimpleTypeSpecifier(*Current.Previous);
Nico Weber37d69312013-02-13 04:13:13 +0000641 bool ParensCouldEndDecl =
Manuel Klimekb3987012013-05-29 14:47:47 +0000642 Current.Next &&
643 Current.Next->isOneOf(tok::equal, tok::semi, tok::l_brace);
Daniel Jasper6a365aa2013-03-13 17:13:53 +0000644 bool IsSizeOfOrAlignOf =
Daniel Jasperb8b42952013-05-31 16:14:28 +0000645 LeftOfParens &&
646 LeftOfParens->isOneOf(tok::kw_sizeof, tok::kw_alignof);
647 if (ParensAreType && !ParensCouldEndDecl && !IsSizeOfOrAlignOf &&
Daniel Jasper0c368782013-07-15 15:04:42 +0000648 (Contexts.back().IsExpression ||
649 (Current.Next && Current.Next->isBinaryOperator())))
Daniel Jasperb8b42952013-05-31 16:14:28 +0000650 IsCast = true;
Daniel Jasper2a409b62013-07-08 14:34:09 +0000651 if (Current.Next && Current.Next->isNot(tok::string_literal) &&
Daniel Jasperb8b42952013-05-31 16:14:28 +0000652 (Current.Next->Tok.isLiteral() ||
653 Current.Next->isOneOf(tok::kw_sizeof, tok::kw_alignof)))
654 IsCast = true;
655 // If there is an identifier after the (), it is likely a cast, unless
656 // there is also an identifier before the ().
Daniel Jasperff1a2e52013-06-06 08:20:20 +0000657 if (LeftOfParens && (LeftOfParens->Tok.getIdentifierInfo() == NULL ||
658 LeftOfParens->is(tok::kw_return)) &&
Daniel Jasper526df0f2013-07-08 14:58:01 +0000659 LeftOfParens->Type != TT_OverloadedOperator &&
Nico Weber465e8612013-06-25 00:55:57 +0000660 LeftOfParens->Type != TT_TemplateCloser && Current.Next &&
661 Current.Next->is(tok::identifier))
Daniel Jasperb8b42952013-05-31 16:14:28 +0000662 IsCast = true;
663 if (IsCast && !ParensAreEmpty)
Nico Weber37d69312013-02-13 04:13:13 +0000664 Current.Type = TT_CastRParen;
Manuel Klimekb3987012013-05-29 14:47:47 +0000665 } else if (Current.is(tok::at) && Current.Next) {
666 switch (Current.Next->Tok.getObjCKeywordID()) {
Daniel Jasper01786732013-02-04 07:21:18 +0000667 case tok::objc_interface:
668 case tok::objc_implementation:
669 case tok::objc_protocol:
670 Current.Type = TT_ObjCDecl;
671 break;
672 case tok::objc_property:
673 Current.Type = TT_ObjCProperty;
674 break;
675 default:
676 break;
677 }
Daniel Jasper5ad390d2013-05-28 11:30:49 +0000678 } else if (Current.is(tok::period)) {
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000679 FormatToken *PreviousNoComment = Current.getPreviousNonComment();
Daniel Jasper5ad390d2013-05-28 11:30:49 +0000680 if (PreviousNoComment &&
681 PreviousNoComment->isOneOf(tok::comma, tok::l_brace))
682 Current.Type = TT_DesignatedInitializerPeriod;
Daniel Jasper01786732013-02-04 07:21:18 +0000683 }
684 }
685 }
686
Daniel Jasper6ac431c2013-07-02 09:47:29 +0000687 /// \brief Take a guess at whether \p Tok starts a name of a function or
688 /// variable declaration.
689 ///
690 /// This is a heuristic based on whether \p Tok is an identifier following
691 /// something that is likely a type.
692 bool isStartOfName(const FormatToken &Tok) {
693 if (Tok.isNot(tok::identifier) || Tok.Previous == NULL)
694 return false;
695
696 // Skip "const" as it does not have an influence on whether this is a name.
697 FormatToken *PreviousNotConst = Tok.Previous;
698 while (PreviousNotConst != NULL && PreviousNotConst->is(tok::kw_const))
699 PreviousNotConst = PreviousNotConst->Previous;
700
701 if (PreviousNotConst == NULL)
702 return false;
703
Daniel Jasper2a409b62013-07-08 14:34:09 +0000704 bool IsPPKeyword = PreviousNotConst->is(tok::identifier) &&
705 PreviousNotConst->Previous &&
706 PreviousNotConst->Previous->is(tok::hash);
Daniel Jasper6ac431c2013-07-02 09:47:29 +0000707
Daniel Jasper92495a82013-08-19 10:16:18 +0000708 if (PreviousNotConst->Type == TT_TemplateCloser)
709 return PreviousNotConst && PreviousNotConst->MatchingParen &&
710 PreviousNotConst->MatchingParen->Previous &&
711 PreviousNotConst->MatchingParen->Previous->isNot(tok::kw_template);
712
Daniel Jasper6ac431c2013-07-02 09:47:29 +0000713 return (!IsPPKeyword && PreviousNotConst->is(tok::identifier)) ||
714 PreviousNotConst->Type == TT_PointerOrReference ||
Daniel Jasper6ac431c2013-07-02 09:47:29 +0000715 isSimpleTypeSpecifier(*PreviousNotConst);
716 }
717
Daniel Jasper01786732013-02-04 07:21:18 +0000718 /// \brief Return the type of the given token assuming it is * or &.
Manuel Klimekb3987012013-05-29 14:47:47 +0000719 TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression) {
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000720 const FormatToken *PrevToken = Tok.getPreviousNonComment();
Daniel Jasper01786732013-02-04 07:21:18 +0000721 if (PrevToken == NULL)
722 return TT_UnaryOperator;
723
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000724 const FormatToken *NextToken = Tok.getNextNonComment();
Daniel Jasper01786732013-02-04 07:21:18 +0000725 if (NextToken == NULL)
726 return TT_Unknown;
727
Daniel Jasper431f5912013-05-28 08:33:00 +0000728 if (PrevToken->is(tok::coloncolon) ||
729 (PrevToken->is(tok::l_paren) && !IsExpression))
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +0000730 return TT_PointerOrReference;
731
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000732 if (PrevToken->isOneOf(tok::l_paren, tok::l_square, tok::l_brace,
Daniel Jasperd3cf17b2013-03-14 10:50:25 +0000733 tok::comma, tok::semi, tok::kw_return, tok::colon,
Daniel Jasperdbef71e2013-05-07 14:17:18 +0000734 tok::equal, tok::kw_delete) ||
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000735 PrevToken->Type == TT_BinaryOperator ||
Daniel Jasper01786732013-02-04 07:21:18 +0000736 PrevToken->Type == TT_UnaryOperator || PrevToken->Type == TT_CastRParen)
737 return TT_UnaryOperator;
738
Nico Webere8a97982013-02-06 06:20:11 +0000739 if (NextToken->is(tok::l_square))
740 return TT_PointerOrReference;
741
Manuel Klimekb3987012013-05-29 14:47:47 +0000742 if (PrevToken->Tok.isLiteral() ||
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000743 PrevToken->isOneOf(tok::r_paren, tok::r_square) ||
Manuel Klimekb3987012013-05-29 14:47:47 +0000744 NextToken->Tok.isLiteral() || NextToken->isUnaryOperator())
Daniel Jasper01786732013-02-04 07:21:18 +0000745 return TT_BinaryOperator;
746
Daniel Jasper01786732013-02-04 07:21:18 +0000747 // It is very unlikely that we are going to find a pointer or reference type
748 // definition on the RHS of an assignment.
749 if (IsExpression)
750 return TT_BinaryOperator;
751
752 return TT_PointerOrReference;
753 }
754
Manuel Klimekb3987012013-05-29 14:47:47 +0000755 TokenType determinePlusMinusCaretUsage(const FormatToken &Tok) {
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000756 const FormatToken *PrevToken = Tok.getPreviousNonComment();
Daniel Jasperb8b42952013-05-31 16:14:28 +0000757 if (PrevToken == NULL || PrevToken->Type == TT_CastRParen)
Daniel Jasper01786732013-02-04 07:21:18 +0000758 return TT_UnaryOperator;
759
760 // Use heuristics to recognize unary operators.
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000761 if (PrevToken->isOneOf(tok::equal, tok::l_paren, tok::comma, tok::l_square,
762 tok::question, tok::colon, tok::kw_return,
763 tok::kw_case, tok::at, tok::l_brace))
Daniel Jasper01786732013-02-04 07:21:18 +0000764 return TT_UnaryOperator;
765
Nico Weberee0feec2013-02-05 16:21:00 +0000766 // There can't be two consecutive binary operators.
Daniel Jasper01786732013-02-04 07:21:18 +0000767 if (PrevToken->Type == TT_BinaryOperator)
768 return TT_UnaryOperator;
769
770 // Fall back to marking the token as binary operator.
771 return TT_BinaryOperator;
772 }
773
774 /// \brief Determine whether ++/-- are pre- or post-increments/-decrements.
Manuel Klimekb3987012013-05-29 14:47:47 +0000775 TokenType determineIncrementUsage(const FormatToken &Tok) {
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000776 const FormatToken *PrevToken = Tok.getPreviousNonComment();
Daniel Jasperb8b42952013-05-31 16:14:28 +0000777 if (PrevToken == NULL || PrevToken->Type == TT_CastRParen)
Daniel Jasper01786732013-02-04 07:21:18 +0000778 return TT_UnaryOperator;
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000779 if (PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::identifier))
Daniel Jasper01786732013-02-04 07:21:18 +0000780 return TT_TrailingUnaryOperator;
781
782 return TT_UnaryOperator;
783 }
Daniel Jasper4e778092013-02-06 10:05:46 +0000784
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000785 // FIXME: This is copy&pasted from Sema. Put it in a common place and remove
786 // duplication.
787 /// \brief Determine whether the token kind starts a simple-type-specifier.
Manuel Klimekb3987012013-05-29 14:47:47 +0000788 bool isSimpleTypeSpecifier(const FormatToken &Tok) const {
789 switch (Tok.Tok.getKind()) {
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000790 case tok::kw_short:
791 case tok::kw_long:
792 case tok::kw___int64:
793 case tok::kw___int128:
794 case tok::kw_signed:
795 case tok::kw_unsigned:
796 case tok::kw_void:
797 case tok::kw_char:
798 case tok::kw_int:
799 case tok::kw_half:
800 case tok::kw_float:
801 case tok::kw_double:
802 case tok::kw_wchar_t:
803 case tok::kw_bool:
804 case tok::kw___underlying_type:
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000805 case tok::annot_typename:
806 case tok::kw_char16_t:
807 case tok::kw_char32_t:
808 case tok::kw_typeof:
809 case tok::kw_decltype:
Alexander Kornienko00895102013-06-05 14:09:10 +0000810 return true;
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000811 default:
Alexander Kornienko00895102013-06-05 14:09:10 +0000812 return false;
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000813 }
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000814 }
815
Daniel Jasper4e778092013-02-06 10:05:46 +0000816 SmallVector<Context, 8> Contexts;
817
Daniel Jasperd4a03db2013-08-22 15:00:41 +0000818 const FormatStyle &Style;
Daniel Jasper4e778092013-02-06 10:05:46 +0000819 AnnotatedLine &Line;
Manuel Klimekb3987012013-05-29 14:47:47 +0000820 FormatToken *CurrentToken;
Daniel Jasper4e778092013-02-06 10:05:46 +0000821 bool KeywordVirtualFound;
Daniel Jasper1407bee2013-04-11 14:29:13 +0000822 bool NameFound;
Daniel Jasper2ca37412013-07-09 14:36:48 +0000823 bool AutoFound;
Nico Weberc2e6d2a2013-02-11 15:32:15 +0000824 IdentifierInfo &Ident_in;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000825};
826
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000827static int PrecedenceUnaryOperator = prec::PointerToMember + 1;
828static int PrecedenceArrowAndPeriod = prec::PointerToMember + 2;
829
Daniel Jasper29f123b2013-02-08 15:28:42 +0000830/// \brief Parses binary expressions by inserting fake parenthesis based on
831/// operator precedence.
832class ExpressionParser {
833public:
Daniel Jasper9acb8b42013-06-06 09:11:58 +0000834 ExpressionParser(AnnotatedLine &Line) : Current(Line.First) {
835 // Skip leading "}", e.g. in "} else if (...) {".
836 if (Current->is(tok::r_brace))
837 next();
838 }
Daniel Jasper29f123b2013-02-08 15:28:42 +0000839
840 /// \brief Parse expressions with the given operatore precedence.
Daniel Jasper237d4c12013-02-23 21:01:55 +0000841 void parse(int Precedence = 0) {
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000842 if (Current == NULL || Precedence > PrecedenceArrowAndPeriod)
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000843 return;
844
Daniel Jasperc01897c2013-05-31 14:56:12 +0000845 // Conditional expressions need to be parsed separately for proper nesting.
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000846 if (Precedence == prec::Conditional) {
Daniel Jasperc01897c2013-05-31 14:56:12 +0000847 parseConditionalExpr();
848 return;
849 }
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000850
851 // Parse unary operators, which all have a higher precedence than binary
852 // operators.
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000853 if (Precedence == PrecedenceUnaryOperator) {
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000854 parseUnaryOperator();
Daniel Jasper29f123b2013-02-08 15:28:42 +0000855 return;
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000856 }
Daniel Jasper29f123b2013-02-08 15:28:42 +0000857
Manuel Klimekb3987012013-05-29 14:47:47 +0000858 FormatToken *Start = Current;
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000859 FormatToken *LatestOperator = NULL;
Daniel Jasper29f123b2013-02-08 15:28:42 +0000860
Daniel Jasper237d4c12013-02-23 21:01:55 +0000861 while (Current) {
Daniel Jasper29f123b2013-02-08 15:28:42 +0000862 // Consume operators with higher precedence.
Daniel Jasperbf71ba22013-04-08 20:33:42 +0000863 parse(Precedence + 1);
Daniel Jasper29f123b2013-02-08 15:28:42 +0000864
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000865 int CurrentPrecedence = getCurrentPrecedence();
866
867 if (Current && Current->Type == TT_ObjCSelectorName &&
868 Precedence == CurrentPrecedence)
869 Start = Current;
Daniel Jasper237d4c12013-02-23 21:01:55 +0000870
Daniel Jasper29f123b2013-02-08 15:28:42 +0000871 // At the end of the line or when an operator with higher precedence is
872 // found, insert fake parenthesis and return.
Daniel Jasperac3223e2013-04-10 09:49:49 +0000873 if (Current == NULL || Current->closesScope() ||
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000874 (CurrentPrecedence != -1 && CurrentPrecedence < Precedence)) {
875 if (LatestOperator) {
876 if (Precedence == PrecedenceArrowAndPeriod) {
877 LatestOperator->LastInChainOfCalls = true;
878 // Call expressions don't have a binary operator precedence.
879 addFakeParenthesis(Start, prec::Unknown);
880 } else {
881 addFakeParenthesis(Start, prec::Level(Precedence));
882 }
883 }
Daniel Jasper29f123b2013-02-08 15:28:42 +0000884 return;
885 }
886
887 // Consume scopes: (), [], <> and {}
Daniel Jasperac3223e2013-04-10 09:49:49 +0000888 if (Current->opensScope()) {
889 while (Current && !Current->closesScope()) {
Daniel Jasper29f123b2013-02-08 15:28:42 +0000890 next();
891 parse();
892 }
893 next();
894 } else {
895 // Operator found.
Daniel Jasper237d4c12013-02-23 21:01:55 +0000896 if (CurrentPrecedence == Precedence)
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000897 LatestOperator = Current;
Daniel Jasper29f123b2013-02-08 15:28:42 +0000898
899 next();
900 }
901 }
902 }
903
904private:
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000905 /// \brief Gets the precedence (+1) of the given token for binary operators
906 /// and other tokens that we treat like binary operators.
907 int getCurrentPrecedence() {
908 if (Current) {
909 if (Current->Type == TT_ConditionalExpr)
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000910 return prec::Conditional;
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000911 else if (Current->is(tok::semi) || Current->Type == TT_InlineASMColon)
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000912 return 0;
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000913 else if (Current->Type == TT_BinaryOperator || Current->is(tok::comma))
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000914 return Current->getPrecedence();
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000915 else if (Current->Type == TT_ObjCSelectorName)
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000916 return prec::Assignment;
917 else if (Current->isOneOf(tok::period, tok::arrow))
918 return PrecedenceArrowAndPeriod;
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000919 }
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000920 return -1;
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000921 }
922
Daniel Jasperc01897c2013-05-31 14:56:12 +0000923 void addFakeParenthesis(FormatToken *Start, prec::Level Precedence) {
924 Start->FakeLParens.push_back(Precedence);
925 if (Current)
926 ++Current->Previous->FakeRParens;
927 }
928
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000929 /// \brief Parse unary operator expressions and surround them with fake
930 /// parentheses if appropriate.
931 void parseUnaryOperator() {
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000932 if (Current == NULL || Current->Type != TT_UnaryOperator) {
933 parse(PrecedenceArrowAndPeriod);
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000934 return;
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000935 }
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000936
937 FormatToken *Start = Current;
938 next();
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000939 parseUnaryOperator();
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000940
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000941 // The actual precedence doesn't matter.
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000942 addFakeParenthesis(Start, prec::Unknown);
Daniel Jasper3618e6f2013-08-23 15:14:03 +0000943 }
944
Daniel Jasperc01897c2013-05-31 14:56:12 +0000945 void parseConditionalExpr() {
946 FormatToken *Start = Current;
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000947 parse(prec::LogicalOr);
Daniel Jasperc01897c2013-05-31 14:56:12 +0000948 if (!Current || !Current->is(tok::question))
949 return;
950 next();
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000951 parse(prec::LogicalOr);
Daniel Jasperc01897c2013-05-31 14:56:12 +0000952 if (!Current || Current->Type != TT_ConditionalExpr)
953 return;
954 next();
955 parseConditionalExpr();
956 addFakeParenthesis(Start, prec::Conditional);
957 }
958
Daniel Jasper29f123b2013-02-08 15:28:42 +0000959 void next() {
Alexander Kornienkod71b15b2013-06-17 13:19:53 +0000960 if (Current)
961 Current = Current->Next;
962 while (Current && Current->isTrailingComment())
Manuel Klimekb3987012013-05-29 14:47:47 +0000963 Current = Current->Next;
Daniel Jasper29f123b2013-02-08 15:28:42 +0000964 }
965
Manuel Klimekb3987012013-05-29 14:47:47 +0000966 FormatToken *Current;
Daniel Jasper29f123b2013-02-08 15:28:42 +0000967};
968
Craig Topper14e66492013-07-01 04:03:19 +0000969} // end anonymous namespace
970
Daniel Jasper8ff690a2013-02-06 14:22:40 +0000971void TokenAnnotator::annotate(AnnotatedLine &Line) {
Daniel Jasperd4a03db2013-08-22 15:00:41 +0000972 AnnotatingParser Parser(Style, Line, Ident_in);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000973 Line.Type = Parser.parseLine();
974 if (Line.Type == LT_Invalid)
975 return;
976
Daniel Jasper29f123b2013-02-08 15:28:42 +0000977 ExpressionParser ExprParser(Line);
978 ExprParser.parse();
979
Manuel Klimekb3987012013-05-29 14:47:47 +0000980 if (Line.First->Type == TT_ObjCMethodSpecifier)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000981 Line.Type = LT_ObjCMethodDecl;
Manuel Klimekb3987012013-05-29 14:47:47 +0000982 else if (Line.First->Type == TT_ObjCDecl)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000983 Line.Type = LT_ObjCDecl;
Manuel Klimekb3987012013-05-29 14:47:47 +0000984 else if (Line.First->Type == TT_ObjCProperty)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000985 Line.Type = LT_ObjCProperty;
986
Manuel Klimekb3987012013-05-29 14:47:47 +0000987 Line.First->SpacesRequiredBefore = 1;
988 Line.First->CanBreakBefore = Line.First->MustBreakBefore;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000989}
990
Daniel Jasper8ff690a2013-02-06 14:22:40 +0000991void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) {
Alexander Kornienko00895102013-06-05 14:09:10 +0000992 Line.First->TotalLength = Line.First->CodePointCount;
Manuel Klimekb3987012013-05-29 14:47:47 +0000993 if (!Line.First->Next)
Daniel Jasper8ff690a2013-02-06 14:22:40 +0000994 return;
Manuel Klimekb3987012013-05-29 14:47:47 +0000995 FormatToken *Current = Line.First->Next;
Daniel Jasper8ff690a2013-02-06 14:22:40 +0000996 while (Current != NULL) {
Daniel Jasper729a7432013-02-11 12:36:37 +0000997 if (Current->Type == TT_LineComment)
998 Current->SpacesRequiredBefore = Style.SpacesBeforeTrailingComments;
999 else
1000 Current->SpacesRequiredBefore =
1001 spaceRequiredBefore(Line, *Current) ? 1 : 0;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001002
Daniel Jasper561211d2013-07-16 20:28:33 +00001003 if (Current->is(tok::comment)) {
Manuel Klimekb3987012013-05-29 14:47:47 +00001004 Current->MustBreakBefore = Current->NewlinesBefore > 0;
1005 } else if (Current->Previous->isTrailingComment() ||
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001006 (Current->is(tok::string_literal) &&
Manuel Klimekb3987012013-05-29 14:47:47 +00001007 Current->Previous->is(tok::string_literal))) {
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001008 Current->MustBreakBefore = true;
Daniel Jasper561211d2013-07-16 20:28:33 +00001009 } else if (Current->Previous->IsUnterminatedLiteral) {
1010 Current->MustBreakBefore = true;
Manuel Klimekb3987012013-05-29 14:47:47 +00001011 } else if (Current->is(tok::lessless) && Current->Next &&
1012 Current->Previous->is(tok::string_literal) &&
1013 Current->Next->is(tok::string_literal)) {
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001014 Current->MustBreakBefore = true;
Manuel Klimekb3987012013-05-29 14:47:47 +00001015 } else if (Current->Previous->ClosesTemplateDeclaration &&
Daniel Jasperbbc87762013-05-29 12:07:31 +00001016 Style.AlwaysBreakTemplateDeclarations) {
1017 Current->MustBreakBefore = true;
Daniel Jaspere8b10d32013-07-26 16:56:36 +00001018 } else if (Current->Type == TT_CtorInitializerComma &&
1019 Style.BreakConstructorInitializersBeforeComma) {
1020 Current->MustBreakBefore = true;
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001021 }
1022 Current->CanBreakBefore =
1023 Current->MustBreakBefore || canBreakBefore(Line, *Current);
Daniel Jasper215c57f2013-07-17 15:38:19 +00001024 if (Current->MustBreakBefore ||
1025 (Current->is(tok::string_literal) &&
1026 Current->TokenText.find("\\\n") != StringRef::npos))
Manuel Klimekb3987012013-05-29 14:47:47 +00001027 Current->TotalLength = Current->Previous->TotalLength + Style.ColumnLimit;
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001028 else
Daniel Jasper2a409b62013-07-08 14:34:09 +00001029 Current->TotalLength = Current->Previous->TotalLength +
1030 Current->CodePointCount +
1031 Current->SpacesRequiredBefore;
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001032 // FIXME: Only calculate this if CanBreakBefore is true once static
1033 // initializers etc. are sorted out.
1034 // FIXME: Move magic numbers to a better place.
1035 Current->SplitPenalty =
1036 20 * Current->BindingStrength + splitPenalty(Line, *Current);
1037
Manuel Klimekb3987012013-05-29 14:47:47 +00001038 Current = Current->Next;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001039 }
Daniel Jasperbf71ba22013-04-08 20:33:42 +00001040
Manuel Klimeke573c3f2013-05-22 12:51:29 +00001041 calculateUnbreakableTailLengths(Line);
Daniel Jasperd4a03db2013-08-22 15:00:41 +00001042 for (Current = Line.First; Current != NULL; Current = Current->Next) {
1043 if (Current->Role)
1044 Current->Role->precomputeFormattingInfos(Current);
1045 }
1046
Daniel Jasperbf71ba22013-04-08 20:33:42 +00001047 DEBUG({
1048 printDebugInfo(Line);
1049 });
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001050}
1051
Manuel Klimeke573c3f2013-05-22 12:51:29 +00001052void TokenAnnotator::calculateUnbreakableTailLengths(AnnotatedLine &Line) {
1053 unsigned UnbreakableTailLength = 0;
Manuel Klimekb3987012013-05-29 14:47:47 +00001054 FormatToken *Current = Line.Last;
Manuel Klimeke573c3f2013-05-22 12:51:29 +00001055 while (Current != NULL) {
1056 Current->UnbreakableTailLength = UnbreakableTailLength;
1057 if (Current->CanBreakBefore ||
1058 Current->isOneOf(tok::comment, tok::string_literal)) {
1059 UnbreakableTailLength = 0;
1060 } else {
1061 UnbreakableTailLength +=
Alexander Kornienko00895102013-06-05 14:09:10 +00001062 Current->CodePointCount + Current->SpacesRequiredBefore;
Manuel Klimeke573c3f2013-05-22 12:51:29 +00001063 }
Manuel Klimekb3987012013-05-29 14:47:47 +00001064 Current = Current->Previous;
Manuel Klimeke573c3f2013-05-22 12:51:29 +00001065 }
1066}
1067
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001068unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line,
Manuel Klimekb3987012013-05-29 14:47:47 +00001069 const FormatToken &Tok) {
1070 const FormatToken &Left = *Tok.Previous;
1071 const FormatToken &Right = Tok;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001072
Daniel Jasper5ad390d2013-05-28 11:30:49 +00001073 if (Left.is(tok::semi))
1074 return 0;
1075 if (Left.is(tok::comma))
1076 return 1;
Daniel Jasper011c35d2013-07-12 11:19:37 +00001077 if (Right.is(tok::l_square))
1078 return 150;
Daniel Jasper5ad390d2013-05-28 11:30:49 +00001079
Daniel Jasper6561f6a2013-07-09 07:43:55 +00001080 if (Right.Type == TT_StartOfName || Right.is(tok::kw_operator)) {
Manuel Klimekb3987012013-05-29 14:47:47 +00001081 if (Line.First->is(tok::kw_for) && Right.PartOfMultiVariableDeclStmt)
Daniel Jasper3c08a812013-02-24 18:54:32 +00001082 return 3;
Daniel Jasperc18cff32013-07-11 12:34:23 +00001083 if (Left.Type == TT_StartOfName)
1084 return 20;
Daniel Jasper92495a82013-08-19 10:16:18 +00001085 if (Line.MightBeFunctionDecl && Right.BindingStrength == 1)
Daniel Jasper3c08a812013-02-24 18:54:32 +00001086 // FIXME: Clean up hack of using BindingStrength to find top-level names.
1087 return Style.PenaltyReturnTypeOnItsOwnLine;
Daniel Jasper92495a82013-08-19 10:16:18 +00001088 return 200;
Daniel Jasper3c08a812013-02-24 18:54:32 +00001089 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001090 if (Left.is(tok::equal) && Right.is(tok::l_brace))
1091 return 150;
Daniel Jasper198c8bf2013-07-05 07:58:34 +00001092 if (Left.Type == TT_CastRParen)
1093 return 100;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001094 if (Left.is(tok::coloncolon))
1095 return 500;
Daniel Jasper6b119d62013-04-05 17:22:09 +00001096 if (Left.isOneOf(tok::kw_class, tok::kw_struct))
1097 return 5000;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001098
Daniel Jasper6cabab42013-02-14 08:42:54 +00001099 if (Left.Type == TT_RangeBasedForLoopColon ||
1100 Left.Type == TT_InheritanceColon)
Daniel Jasper84a1a632013-02-26 13:18:08 +00001101 return 2;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001102
Daniel Jasperd3fef0f2013-08-27 14:24:43 +00001103 if (Right.isMemberAccess()) {
1104 if (Left.isOneOf(tok::r_paren, tok::r_square))
Daniel Jasper518ee342013-02-26 13:59:14 +00001105 return 20; // Should be smaller than breaking at a nested comma.
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001106 return 150;
1107 }
1108
Daniel Jasper20a0f8c2013-07-11 21:02:56 +00001109 // Breaking before a trailing 'const' or not-function-like annotation is bad.
Daniel Jasperaa9e7b12013-08-01 13:46:58 +00001110 if (Left.is(tok::r_paren) && Line.Type != LT_ObjCProperty &&
Daniel Jasper20a0f8c2013-07-11 21:02:56 +00001111 (Right.is(tok::kw_const) || (Right.is(tok::identifier) && Right.Next &&
1112 Right.Next->isNot(tok::l_paren))))
Daniel Jasper5ad72bb2013-05-22 08:28:26 +00001113 return 150;
1114
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001115 // In for-loops, prefer breaking at ',' and ';'.
Manuel Klimekb3987012013-05-29 14:47:47 +00001116 if (Line.First->is(tok::kw_for) && Left.is(tok::equal))
Daniel Jasper7d812812013-02-21 15:00:29 +00001117 return 4;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001118
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001119 // In Objective-C method expressions, prefer breaking before "param:" over
1120 // breaking after it.
Daniel Jasper63d7ced2013-02-05 10:07:47 +00001121 if (Right.Type == TT_ObjCSelectorName)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001122 return 0;
Daniel Jasper63d7ced2013-02-05 10:07:47 +00001123 if (Left.is(tok::colon) && Left.Type == TT_ObjCMethodExpr)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001124 return 20;
1125
Daniel Jasper1407bee2013-04-11 14:29:13 +00001126 if (Left.is(tok::l_paren) && Line.MightBeFunctionDecl)
1127 return 100;
Daniel Jasperac3223e2013-04-10 09:49:49 +00001128 if (Left.opensScope())
Daniel Jaspere60084d2013-08-13 06:50:04 +00001129 return Left.ParameterCount > 1 ? prec::Comma : 19;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001130
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00001131 if (Right.is(tok::lessless)) {
1132 if (Left.is(tok::string_literal)) {
Alexander Kornienko00895102013-06-05 14:09:10 +00001133 StringRef Content = Left.TokenText;
Daniel Jasperbfa1edd2013-03-14 14:00:17 +00001134 Content = Content.drop_back(1).drop_front(1).trim();
1135 if (Content.size() > 1 &&
1136 (Content.back() == ':' || Content.back() == '='))
Daniel Jasper9637dda2013-07-15 14:33:14 +00001137 return 25;
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00001138 }
Daniel Jasper0c368782013-07-15 15:04:42 +00001139 return 1; // Breaking at a << is really cheap.
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00001140 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001141 if (Left.Type == TT_ConditionalExpr)
Daniel Jasper518ee342013-02-26 13:59:14 +00001142 return prec::Conditional;
Manuel Klimekb3987012013-05-29 14:47:47 +00001143 prec::Level Level = Left.getPrecedence();
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001144
1145 if (Level != prec::Unknown)
1146 return Level;
Daniel Jasper24849712013-03-01 16:48:32 +00001147
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001148 return 3;
1149}
1150
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001151bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
Manuel Klimekb3987012013-05-29 14:47:47 +00001152 const FormatToken &Left,
1153 const FormatToken &Right) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001154 if (Right.is(tok::hashhash))
1155 return Left.is(tok::hash);
Alexander Kornienkoe74de282013-03-13 14:41:29 +00001156 if (Left.isOneOf(tok::hashhash, tok::hash))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001157 return Right.is(tok::hash);
Daniel Jasper7df56bf2013-08-20 12:36:34 +00001158 if (Left.is(tok::l_paren) && Right.is(tok::r_paren))
1159 return Style.SpaceInEmptyParentheses;
1160 if (Left.is(tok::l_paren) || Right.is(tok::r_paren))
Daniel Jasper34f3d052013-08-21 08:39:01 +00001161 return (Right.Type == TT_CastRParen ||
1162 (Left.MatchingParen && Left.MatchingParen->Type == TT_CastRParen))
Daniel Jasper7df56bf2013-08-20 12:36:34 +00001163 ? Style.SpacesInCStyleCastParentheses
1164 : Style.SpacesInParentheses;
1165 if (Right.isOneOf(tok::semi, tok::comma))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001166 return false;
1167 if (Right.is(tok::less) &&
1168 (Left.is(tok::kw_template) ||
1169 (Line.Type == LT_ObjCDecl && Style.ObjCSpaceBeforeProtocolList)))
1170 return true;
1171 if (Left.is(tok::arrow) || Right.is(tok::arrow))
1172 return false;
Alexander Kornienkoe74de282013-03-13 14:41:29 +00001173 if (Left.isOneOf(tok::exclaim, tok::tilde))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001174 return false;
1175 if (Left.is(tok::at) &&
Alexander Kornienkoe74de282013-03-13 14:41:29 +00001176 Right.isOneOf(tok::identifier, tok::string_literal, tok::char_constant,
1177 tok::numeric_constant, tok::l_paren, tok::l_brace,
1178 tok::kw_true, tok::kw_false))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001179 return false;
1180 if (Left.is(tok::coloncolon))
1181 return false;
1182 if (Right.is(tok::coloncolon))
Daniel Jasper081fc172013-08-28 07:07:07 +00001183 return !Left.isOneOf(tok::identifier, tok::greater, tok::l_paren,
1184 tok::r_paren);
Alexander Kornienkoe74de282013-03-13 14:41:29 +00001185 if (Left.is(tok::less) || Right.isOneOf(tok::greater, tok::less))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001186 return false;
Daniel Jasperc47d7f12013-07-01 09:47:25 +00001187 if (Right.is(tok::ellipsis))
1188 return false;
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00001189 if (Right.Type == TT_PointerOrReference)
Manuel Klimekb3987012013-05-29 14:47:47 +00001190 return Left.Tok.isLiteral() ||
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00001191 ((Left.Type != TT_PointerOrReference) && Left.isNot(tok::l_paren) &&
1192 !Style.PointerBindsToType);
Daniel Jasper3ff4a2f2013-05-28 15:27:10 +00001193 if (Right.Type == TT_FunctionTypeLParen && Left.isNot(tok::l_paren) &&
Daniel Jasper395228f2013-05-08 14:58:20 +00001194 (Left.Type != TT_PointerOrReference || Style.PointerBindsToType))
1195 return true;
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00001196 if (Left.Type == TT_PointerOrReference)
Daniel Jasper3a1847e2013-07-01 09:34:09 +00001197 return Right.Tok.isLiteral() || Right.Type == TT_BlockComment ||
Daniel Jasper9322aae2013-03-20 09:53:18 +00001198 ((Right.Type != TT_PointerOrReference) &&
Daniel Jasper81d2d382013-04-01 17:13:26 +00001199 Right.isNot(tok::l_paren) && Style.PointerBindsToType &&
Manuel Klimekb3987012013-05-29 14:47:47 +00001200 Left.Previous &&
1201 !Left.Previous->isOneOf(tok::l_paren, tok::coloncolon));
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001202 if (Right.is(tok::star) && Left.is(tok::l_paren))
1203 return false;
Nico Weber051860e2013-02-10 02:08:05 +00001204 if (Left.is(tok::l_square))
1205 return Left.Type == TT_ObjCArrayLiteral && Right.isNot(tok::r_square);
1206 if (Right.is(tok::r_square))
1207 return Right.Type == TT_ObjCArrayLiteral;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001208 if (Right.is(tok::l_square) && Right.Type != TT_ObjCMethodExpr)
1209 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001210 if (Left.is(tok::colon))
1211 return Left.Type != TT_ObjCMethodExpr;
1212 if (Right.is(tok::colon))
Daniel Jasperab3ce592013-08-01 22:05:00 +00001213 return Right.Type != TT_ObjCMethodExpr && !Left.is(tok::question);
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001214 if (Right.is(tok::l_paren)) {
Daniel Jaspere0fa4c52013-07-17 20:25:02 +00001215 if (Left.is(tok::r_paren) && Left.MatchingParen &&
1216 Left.MatchingParen->Previous &&
1217 Left.MatchingParen->Previous->is(tok::kw___attribute))
1218 return true;
Alexander Kornienkoe74de282013-03-13 14:41:29 +00001219 return Line.Type == LT_ObjCDecl ||
Daniel Jasper34f3d052013-08-21 08:39:01 +00001220 Left.isOneOf(tok::kw_return, tok::kw_new, tok::kw_delete,
1221 tok::semi) ||
1222 (Style.SpaceAfterControlStatementKeyword &&
1223 Left.isOneOf(tok::kw_if, tok::kw_for, tok::kw_while, tok::kw_switch,
1224 tok::kw_catch));
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001225 }
Manuel Klimekb3987012013-05-29 14:47:47 +00001226 if (Left.is(tok::at) && Right.Tok.getObjCKeywordID() != tok::objc_not_keyword)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001227 return false;
1228 if (Left.is(tok::l_brace) && Right.is(tok::r_brace))
Daniel Jasper2424eef2013-05-23 10:15:45 +00001229 return false; // No spaces in "{}".
1230 if (Left.is(tok::l_brace) || Right.is(tok::r_brace))
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00001231 return !Style.Cpp11BracedListStyle;
Daniel Jasper1bee0732013-05-23 18:05:18 +00001232 if (Right.Type == TT_UnaryOperator)
1233 return !Left.isOneOf(tok::l_paren, tok::l_square, tok::at) &&
1234 (Left.isNot(tok::colon) || Left.Type != TT_ObjCMethodExpr);
Daniel Jasperce933562013-05-23 21:35:49 +00001235 if (Left.isOneOf(tok::identifier, tok::greater, tok::r_square) &&
Alexander Kornienko0bdc6432013-07-04 14:47:51 +00001236 Right.is(tok::l_brace) && Right.getNextNonComment())
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001237 return false;
Daniel Jasper5ad390d2013-05-28 11:30:49 +00001238 if (Left.is(tok::period) || Right.is(tok::period))
1239 return false;
Nico Weber861576b2013-06-26 00:15:19 +00001240 if (Left.Type == TT_BlockComment && Left.TokenText.endswith("=*/"))
1241 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001242 return true;
1243}
1244
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001245bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line,
Manuel Klimekb3987012013-05-29 14:47:47 +00001246 const FormatToken &Tok) {
1247 if (Tok.Tok.getIdentifierInfo() && Tok.Previous->Tok.getIdentifierInfo())
Daniel Jasper2b4c9242013-02-11 08:01:18 +00001248 return true; // Never ever merge two identifiers.
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001249 if (Line.Type == LT_ObjCMethodDecl) {
Manuel Klimekb3987012013-05-29 14:47:47 +00001250 if (Tok.Previous->Type == TT_ObjCMethodSpecifier)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001251 return true;
Manuel Klimekb3987012013-05-29 14:47:47 +00001252 if (Tok.Previous->is(tok::r_paren) && Tok.is(tok::identifier))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001253 // Don't space between ')' and <id>
1254 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001255 }
1256 if (Line.Type == LT_ObjCProperty &&
Manuel Klimekb3987012013-05-29 14:47:47 +00001257 (Tok.is(tok::equal) || Tok.Previous->is(tok::equal)))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001258 return false;
1259
Daniel Jasper2ca37412013-07-09 14:36:48 +00001260 if (Tok.Type == TT_TrailingReturnArrow ||
1261 Tok.Previous->Type == TT_TrailingReturnArrow)
1262 return true;
Manuel Klimekb3987012013-05-29 14:47:47 +00001263 if (Tok.Previous->is(tok::comma))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001264 return true;
Daniel Jasper9c3c7b32013-02-28 13:40:17 +00001265 if (Tok.is(tok::comma))
1266 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001267 if (Tok.Type == TT_CtorInitializerColon || Tok.Type == TT_ObjCBlockLParen)
1268 return true;
Manuel Klimekb3987012013-05-29 14:47:47 +00001269 if (Tok.Previous->Tok.is(tok::kw_operator))
Daniel Jasper2b4c9242013-02-11 08:01:18 +00001270 return false;
1271 if (Tok.Type == TT_OverloadedOperatorLParen)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001272 return false;
1273 if (Tok.is(tok::colon))
Manuel Klimekb3987012013-05-29 14:47:47 +00001274 return !Line.First->isOneOf(tok::kw_case, tok::kw_default) &&
Daniel Jasperab3ce592013-08-01 22:05:00 +00001275 Tok.getNextNonComment() != NULL && Tok.Type != TT_ObjCMethodExpr &&
1276 !Tok.Previous->is(tok::question);
Manuel Klimekb3987012013-05-29 14:47:47 +00001277 if (Tok.Previous->Type == TT_UnaryOperator ||
1278 Tok.Previous->Type == TT_CastRParen)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001279 return false;
Manuel Klimekb3987012013-05-29 14:47:47 +00001280 if (Tok.Previous->is(tok::greater) && Tok.is(tok::greater)) {
Daniel Jasper29f123b2013-02-08 15:28:42 +00001281 return Tok.Type == TT_TemplateCloser &&
Manuel Klimekb3987012013-05-29 14:47:47 +00001282 Tok.Previous->Type == TT_TemplateCloser &&
Daniel Jasper29f123b2013-02-08 15:28:42 +00001283 Style.Standard != FormatStyle::LS_Cpp11;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001284 }
Alexander Kornienko54a38bd2013-03-20 16:41:56 +00001285 if (Tok.isOneOf(tok::arrowstar, tok::periodstar) ||
Manuel Klimekb3987012013-05-29 14:47:47 +00001286 Tok.Previous->isOneOf(tok::arrowstar, tok::periodstar))
Daniel Jasper9c3c7b32013-02-28 13:40:17 +00001287 return false;
Daniel Jasper1dc6f742013-08-07 16:29:23 +00001288 if ((Tok.Type == TT_BinaryOperator && !Tok.Previous->is(tok::l_paren)) ||
1289 Tok.Previous->Type == TT_BinaryOperator)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001290 return true;
Manuel Klimekb3987012013-05-29 14:47:47 +00001291 if (Tok.Previous->Type == TT_TemplateCloser && Tok.is(tok::l_paren))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001292 return false;
Manuel Klimekb3987012013-05-29 14:47:47 +00001293 if (Tok.is(tok::less) && Line.First->is(tok::hash))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001294 return true;
1295 if (Tok.Type == TT_TrailingUnaryOperator)
1296 return false;
Manuel Klimekb3987012013-05-29 14:47:47 +00001297 return spaceRequiredBetween(Line, *Tok.Previous, Tok);
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001298}
1299
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001300bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line,
Manuel Klimekb3987012013-05-29 14:47:47 +00001301 const FormatToken &Right) {
1302 const FormatToken &Left = *Right.Previous;
Daniel Jasper6561f6a2013-07-09 07:43:55 +00001303 if (Right.Type == TT_StartOfName || Right.is(tok::kw_operator))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001304 return true;
Nico Weberf2ff8122013-05-26 05:39:26 +00001305 if (Right.is(tok::colon) &&
1306 (Right.Type == TT_ObjCDictLiteral || Right.Type == TT_ObjCMethodExpr))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001307 return false;
Nico Weberf2ff8122013-05-26 05:39:26 +00001308 if (Left.is(tok::colon) &&
1309 (Left.Type == TT_ObjCDictLiteral || Left.Type == TT_ObjCMethodExpr))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001310 return true;
Daniel Jasper63d7ced2013-02-05 10:07:47 +00001311 if (Right.Type == TT_ObjCSelectorName)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001312 return true;
Daniel Jasperaa9e7b12013-08-01 13:46:58 +00001313 if (Left.is(tok::r_paren) && Line.Type == LT_ObjCProperty)
1314 return true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001315 if (Left.ClosesTemplateDeclaration)
1316 return true;
Daniel Jasperab3ce592013-08-01 22:05:00 +00001317 if ((Right.Type == TT_ConditionalExpr &&
1318 !(Right.is(tok::colon) && Left.is(tok::question))) ||
1319 Right.is(tok::question))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001320 return true;
Daniel Jasper6cabab42013-02-14 08:42:54 +00001321 if (Right.Type == TT_RangeBasedForLoopColon ||
Daniel Jasper27b91cc2013-04-05 17:21:59 +00001322 Right.Type == TT_OverloadedOperatorLParen)
Daniel Jasper6cabab42013-02-14 08:42:54 +00001323 return false;
Daniel Jasperc194c952013-05-06 06:45:09 +00001324 if (Left.Type == TT_RangeBasedForLoopColon)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001325 return true;
Daniel Jasper7d812812013-02-21 15:00:29 +00001326 if (Right.Type == TT_RangeBasedForLoopColon)
1327 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001328 if (Left.Type == TT_PointerOrReference || Left.Type == TT_TemplateCloser ||
1329 Left.Type == TT_UnaryOperator || Left.Type == TT_ConditionalExpr ||
Alexander Kornienkoe74de282013-03-13 14:41:29 +00001330 Left.isOneOf(tok::question, tok::kw_operator))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001331 return false;
1332 if (Left.is(tok::equal) && Line.Type == LT_VirtualFunctionDecl)
1333 return false;
Daniel Jasper198c8bf2013-07-05 07:58:34 +00001334 if (Left.Previous) {
1335 if (Left.is(tok::l_paren) && Right.is(tok::l_paren) &&
1336 Left.Previous->is(tok::kw___attribute))
1337 return false;
Daniel Jasper2ca37412013-07-09 14:36:48 +00001338 if (Left.is(tok::l_paren) && (Left.Previous->Type == TT_BinaryOperator ||
Daniel Jasper5e2169f2013-07-18 14:46:07 +00001339 Left.Previous->Type == TT_CastRParen))
Daniel Jasper198c8bf2013-07-05 07:58:34 +00001340 return false;
1341 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001342
Daniel Jasper65d2c382013-06-06 16:08:57 +00001343 if (Right.isTrailingComment())
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001344 // We rely on MustBreakBefore being set correctly here as we should not
1345 // change the "binding" behavior of a comment.
1346 return false;
1347
Daniel Jasper5ad72bb2013-05-22 08:28:26 +00001348 // We only break before r_brace if there was a corresponding break before
1349 // the l_brace, which is tracked by BreakBeforeClosingBrace.
Daniel Jaspere8b10d32013-07-26 16:56:36 +00001350 if (Right.isOneOf(tok::r_brace, tok::r_paren) ||
1351 Right.Type == TT_TemplateCloser)
Daniel Jasper5ad72bb2013-05-22 08:28:26 +00001352 return false;
1353
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001354 // Allow breaking after a trailing 'const', e.g. after a method declaration,
1355 // unless it is follow by ';', '{' or '='.
Manuel Klimekb3987012013-05-29 14:47:47 +00001356 if (Left.is(tok::kw_const) && Left.Previous != NULL &&
1357 Left.Previous->is(tok::r_paren))
Alexander Kornienkoe74de282013-03-13 14:41:29 +00001358 return !Right.isOneOf(tok::l_brace, tok::semi, tok::equal);
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001359
Daniel Jasper8ef19a22013-03-14 09:50:46 +00001360 if (Right.is(tok::kw___attribute))
1361 return true;
1362
Daniel Jasper3a204412013-02-23 07:46:38 +00001363 if (Left.is(tok::identifier) && Right.is(tok::string_literal))
1364 return true;
Daniel Jaspere8b10d32013-07-26 16:56:36 +00001365
1366 if (Left.Type == TT_CtorInitializerComma &&
1367 Style.BreakConstructorInitializersBeforeComma)
1368 return false;
1369 if (Right.isBinaryOperator() && Style.BreakBeforeBinaryOperators)
1370 return true;
1371 return (Left.isBinaryOperator() && Left.isNot(tok::lessless) &&
1372 !Style.BreakBeforeBinaryOperators) ||
Daniel Jasper6b119d62013-04-05 17:22:09 +00001373 Left.isOneOf(tok::comma, tok::coloncolon, tok::semi, tok::l_brace,
1374 tok::kw_class, tok::kw_struct) ||
Alexander Kornienkoe74de282013-03-13 14:41:29 +00001375 Right.isOneOf(tok::lessless, tok::arrow, tok::period, tok::colon) ||
Daniel Jasper198c8bf2013-07-05 07:58:34 +00001376 (Left.is(tok::r_paren) &&
Daniel Jaspere033e872013-05-21 09:16:31 +00001377 Right.isOneOf(tok::identifier, tok::kw_const, tok::kw___attribute)) ||
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001378 (Left.is(tok::l_paren) && !Right.is(tok::r_paren)) ||
Daniel Jasper011c35d2013-07-12 11:19:37 +00001379 Right.is(tok::l_square);
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001380}
1381
Daniel Jasperbf71ba22013-04-08 20:33:42 +00001382void TokenAnnotator::printDebugInfo(const AnnotatedLine &Line) {
1383 llvm::errs() << "AnnotatedTokens:\n";
Manuel Klimekb3987012013-05-29 14:47:47 +00001384 const FormatToken *Tok = Line.First;
Daniel Jasperbf71ba22013-04-08 20:33:42 +00001385 while (Tok) {
Manuel Klimekb3987012013-05-29 14:47:47 +00001386 llvm::errs() << " M=" << Tok->MustBreakBefore
Daniel Jasperc7bd68f2013-07-10 14:02:49 +00001387 << " C=" << Tok->CanBreakBefore << " T=" << Tok->Type
1388 << " S=" << Tok->SpacesRequiredBefore
1389 << " P=" << Tok->SplitPenalty << " Name=" << Tok->Tok.getName()
1390 << " PPK=" << Tok->PackingKind << " FakeLParens=";
Daniel Jasperbf71ba22013-04-08 20:33:42 +00001391 for (unsigned i = 0, e = Tok->FakeLParens.size(); i != e; ++i)
1392 llvm::errs() << Tok->FakeLParens[i] << "/";
1393 llvm::errs() << " FakeRParens=" << Tok->FakeRParens << "\n";
Manuel Klimekb3987012013-05-29 14:47:47 +00001394 Tok = Tok->Next;
Daniel Jasperbf71ba22013-04-08 20:33:42 +00001395 }
1396 llvm::errs() << "----\n";
1397}
1398
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001399} // namespace format
1400} // namespace clang