blob: 3fea52b9f8af86c177259f9fc114a0c50307cc4a [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
Stephen Hines6bcf27b2014-05-29 04:14:42 -070020#define DEBUG_TYPE "format-token-annotator"
21
Daniel Jasper32d28ee2013-01-29 21:01:14 +000022namespace clang {
23namespace format {
24
Craig Topper14e66492013-07-01 04:03:19 +000025namespace {
26
Daniel Jasper32d28ee2013-01-29 21:01:14 +000027/// \brief A parser that gathers additional information about tokens.
28///
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +000029/// The \c TokenAnnotator tries to match parenthesis and square brakets and
Daniel Jasper32d28ee2013-01-29 21:01:14 +000030/// store a parenthesis levels. It also tries to resolve matching "<" and ">"
31/// into template parameter lists.
32class AnnotatingParser {
33public:
Daniel Jasperd4a03db2013-08-22 15:00:41 +000034 AnnotatingParser(const FormatStyle &Style, AnnotatedLine &Line,
35 IdentifierInfo &Ident_in)
36 : Style(Style), Line(Line), CurrentToken(Line.First),
Daniel Jasper59875ac2013-11-07 17:43:07 +000037 KeywordVirtualFound(false), AutoFound(false), Ident_in(Ident_in) {
Nico Weber27268772013-06-26 00:30:14 +000038 Contexts.push_back(Context(tok::unknown, 1, /*IsExpression=*/false));
Stephen Hines651f13c2014-04-23 16:59:28 -070039 resetTokenMetadata(CurrentToken);
Daniel Jasper32d28ee2013-01-29 21:01:14 +000040 }
41
Nico Weber95e8e462013-02-12 16:17:07 +000042private:
Daniel Jasper32d28ee2013-01-29 21:01:14 +000043 bool parseAngle() {
Stephen Hines6bcf27b2014-05-29 04:14:42 -070044 if (!CurrentToken)
Daniel Jasper32d28ee2013-01-29 21:01:14 +000045 return false;
Daniel Jasper923ebef2013-03-14 13:45:21 +000046 ScopedContextCreator ContextCreator(*this, tok::less, 10);
Manuel Klimekb3987012013-05-29 14:47:47 +000047 FormatToken *Left = CurrentToken->Previous;
Daniel Jasper4e778092013-02-06 10:05:46 +000048 Contexts.back().IsExpression = false;
Stephen Hines651f13c2014-04-23 16:59:28 -070049 // If there's a template keyword before the opening angle bracket, this is a
50 // template parameter, not an argument.
51 Contexts.back().InTemplateArgument =
Stephen Hines6bcf27b2014-05-29 04:14:42 -070052 Left->Previous && Left->Previous->Tok.isNot(tok::kw_template);
Stephen Hines651f13c2014-04-23 16:59:28 -070053
Stephen Hines6bcf27b2014-05-29 04:14:42 -070054 while (CurrentToken) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +000055 if (CurrentToken->is(tok::greater)) {
56 Left->MatchingParen = CurrentToken;
57 CurrentToken->MatchingParen = Left;
58 CurrentToken->Type = TT_TemplateCloser;
59 next();
60 return true;
61 }
Alexander Kornienkoe74de282013-03-13 14:41:29 +000062 if (CurrentToken->isOneOf(tok::r_paren, tok::r_square, tok::r_brace,
Daniel Jasper5d823e32013-05-15 13:46:48 +000063 tok::question, tok::colon))
64 return false;
Daniel Jasper0348be02013-06-01 18:56:00 +000065 // If a && or || is found and interpreted as a binary operator, this set
Daniel Jasper15f33f02013-06-03 16:16:41 +000066 // of angles is likely part of something like "a < b && c > d". If the
Daniel Jasper0348be02013-06-01 18:56:00 +000067 // angles are inside an expression, the ||/&& might also be a binary
68 // operator that was misinterpreted because we are parsing template
69 // parameters.
70 // FIXME: This is getting out of hand, write a decent parser.
Manuel Klimekb3987012013-05-29 14:47:47 +000071 if (CurrentToken->Previous->isOneOf(tok::pipepipe, tok::ampamp) &&
Stephen Hines651f13c2014-04-23 16:59:28 -070072 ((CurrentToken->Previous->Type == TT_BinaryOperator &&
73 // Toplevel bool expressions do not make lots of sense;
74 // If we're on the top level, it contains only the base context and
75 // the context for the current opening angle bracket.
76 Contexts.size() > 2) ||
Daniel Jasper0348be02013-06-01 18:56:00 +000077 Contexts[Contexts.size() - 2].IsExpression) &&
Manuel Klimekb3987012013-05-29 14:47:47 +000078 Line.First->isNot(tok::kw_template))
Daniel Jasper32d28ee2013-01-29 21:01:14 +000079 return false;
Daniel Jasper9fc56f22013-02-14 15:01:34 +000080 updateParameterCount(Left, CurrentToken);
Daniel Jasper32d28ee2013-01-29 21:01:14 +000081 if (!consumeToken())
82 return false;
83 }
84 return false;
85 }
86
87 bool parseParens(bool LookForDecls = false) {
Stephen Hines6bcf27b2014-05-29 04:14:42 -070088 if (!CurrentToken)
Daniel Jasper32d28ee2013-01-29 21:01:14 +000089 return false;
Daniel Jasper923ebef2013-03-14 13:45:21 +000090 ScopedContextCreator ContextCreator(*this, tok::l_paren, 1);
Daniel Jasper4e778092013-02-06 10:05:46 +000091
92 // FIXME: This is a bit of a hack. Do better.
93 Contexts.back().ColonIsForRangeExpr =
94 Contexts.size() == 2 && Contexts[0].ColonIsForRangeExpr;
95
Daniel Jasper32d28ee2013-01-29 21:01:14 +000096 bool StartsObjCMethodExpr = false;
Manuel Klimekb3987012013-05-29 14:47:47 +000097 FormatToken *Left = CurrentToken->Previous;
Daniel Jasper32d28ee2013-01-29 21:01:14 +000098 if (CurrentToken->is(tok::caret)) {
Stephen Hines651f13c2014-04-23 16:59:28 -070099 // (^ can start a block type.
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000100 Left->Type = TT_ObjCBlockLParen;
Manuel Klimekb3987012013-05-29 14:47:47 +0000101 } else if (FormatToken *MaybeSel = Left->Previous) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000102 // @selector( starts a selector.
Manuel Klimekb3987012013-05-29 14:47:47 +0000103 if (MaybeSel->isObjCAtKeyword(tok::objc_selector) && MaybeSel->Previous &&
104 MaybeSel->Previous->is(tok::at)) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000105 StartsObjCMethodExpr = true;
106 }
107 }
108
Stephen Hines651f13c2014-04-23 16:59:28 -0700109 if (Left->Previous &&
110 (Left->Previous->isOneOf(tok::kw_static_assert, tok::kw_if,
111 tok::kw_while, tok::l_paren, tok::comma) ||
112 Left->Previous->Type == TT_BinaryOperator)) {
Daniel Jasper363193b2013-10-20 18:15:30 +0000113 // static_assert, if and while usually contain expressions.
Daniel Jasperb7000ca2013-08-01 17:58:23 +0000114 Contexts.back().IsExpression = true;
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700115 } else if (Line.InPPDirective &&
116 (!Left->Previous ||
117 (Left->Previous->isNot(tok::identifier) &&
118 Left->Previous->Type != TT_OverloadedOperator))) {
119 Contexts.back().IsExpression = true;
Daniel Jasper363193b2013-10-20 18:15:30 +0000120 } else if (Left->Previous && Left->Previous->is(tok::r_square) &&
121 Left->Previous->MatchingParen &&
122 Left->Previous->MatchingParen->Type == TT_LambdaLSquare) {
123 // This is a parameter list of a lambda expression.
124 Contexts.back().IsExpression = false;
Stephen Hines651f13c2014-04-23 16:59:28 -0700125 } else if (Contexts[Contexts.size() - 2].CaretFound) {
126 // This is the parameter list of an ObjC block.
127 Contexts.back().IsExpression = false;
128 } else if (Left->Previous && Left->Previous->is(tok::kw___attribute)) {
129 Left->Type = TT_AttributeParen;
130 } else if (Left->Previous && Left->Previous->IsForEachMacro) {
131 // The first argument to a foreach macro is a declaration.
132 Contexts.back().IsForEachMacro = true;
133 Contexts.back().IsExpression = false;
Daniel Jasper363193b2013-10-20 18:15:30 +0000134 }
Daniel Jasperb7000ca2013-08-01 17:58:23 +0000135
Daniel Jasper4e778092013-02-06 10:05:46 +0000136 if (StartsObjCMethodExpr) {
137 Contexts.back().ColonIsObjCMethodExpr = true;
138 Left->Type = TT_ObjCMethodExpr;
139 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000140
Daniel Jasper431f5912013-05-28 08:33:00 +0000141 bool MightBeFunctionType = CurrentToken->is(tok::star);
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000142 bool HasMultipleLines = false;
143 bool HasMultipleParametersOnALine = false;
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700144 while (CurrentToken) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000145 // LookForDecls is set when "if (" has been seen. Check for
146 // 'identifier' '*' 'identifier' followed by not '=' -- this
147 // '*' has to be a binary operator but determineStarAmpUsage() will
148 // categorize it as an unary operator, so set the right type here.
Manuel Klimekb3987012013-05-29 14:47:47 +0000149 if (LookForDecls && CurrentToken->Next) {
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000150 FormatToken *Prev = CurrentToken->getPreviousNonComment();
Alexander Kornienko2785b9a2013-06-07 16:02:52 +0000151 if (Prev) {
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000152 FormatToken *PrevPrev = Prev->getPreviousNonComment();
Alexander Kornienko2785b9a2013-06-07 16:02:52 +0000153 FormatToken *Next = CurrentToken->Next;
154 if (PrevPrev && PrevPrev->is(tok::identifier) &&
155 Prev->isOneOf(tok::star, tok::amp, tok::ampamp) &&
156 CurrentToken->is(tok::identifier) && Next->isNot(tok::equal)) {
157 Prev->Type = TT_BinaryOperator;
158 LookForDecls = false;
159 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000160 }
161 }
162
Daniel Jasper53352602013-08-12 12:16:34 +0000163 if (CurrentToken->Previous->Type == TT_PointerOrReference &&
164 CurrentToken->Previous->Previous->isOneOf(tok::l_paren,
165 tok::coloncolon))
166 MightBeFunctionType = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000167 if (CurrentToken->is(tok::r_paren)) {
Manuel Klimekb3987012013-05-29 14:47:47 +0000168 if (MightBeFunctionType && CurrentToken->Next &&
Daniel Jaspere7d3bff2013-07-16 11:37:21 +0000169 (CurrentToken->Next->is(tok::l_paren) ||
170 (CurrentToken->Next->is(tok::l_square) &&
171 !Contexts.back().IsExpression)))
Daniel Jasper431f5912013-05-28 08:33:00 +0000172 Left->Type = TT_FunctionTypeLParen;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000173 Left->MatchingParen = CurrentToken;
174 CurrentToken->MatchingParen = Left;
175
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000176 if (StartsObjCMethodExpr) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000177 CurrentToken->Type = TT_ObjCMethodExpr;
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700178 if (Contexts.back().FirstObjCSelectorName) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000179 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
180 Contexts.back().LongestObjCSelectorName;
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000181 }
182 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000183
Stephen Hines651f13c2014-04-23 16:59:28 -0700184 if (Left->Type == TT_AttributeParen)
185 CurrentToken->Type = TT_AttributeParen;
186
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000187 if (!HasMultipleLines)
188 Left->PackingKind = PPK_Inconclusive;
189 else if (HasMultipleParametersOnALine)
190 Left->PackingKind = PPK_BinPacked;
191 else
192 Left->PackingKind = PPK_OnePerLine;
193
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000194 next();
195 return true;
196 }
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000197 if (CurrentToken->isOneOf(tok::r_square, tok::r_brace))
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000198 return false;
Stephen Hines651f13c2014-04-23 16:59:28 -0700199 else if (CurrentToken->is(tok::l_brace))
200 Left->Type = TT_Unknown; // Not TT_ObjCBlockLParen
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000201 updateParameterCount(Left, CurrentToken);
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000202 if (CurrentToken->is(tok::comma) && CurrentToken->Next &&
203 !CurrentToken->Next->HasUnescapedNewline &&
204 !CurrentToken->Next->isTrailingComment())
205 HasMultipleParametersOnALine = true;
Stephen Hines651f13c2014-04-23 16:59:28 -0700206 if (CurrentToken->isOneOf(tok::kw_const, tok::kw_auto) ||
207 CurrentToken->isSimpleTypeSpecifier())
208 Contexts.back().IsExpression = false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000209 if (!consumeToken())
210 return false;
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000211 if (CurrentToken && CurrentToken->HasUnescapedNewline)
212 HasMultipleLines = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000213 }
214 return false;
215 }
216
217 bool parseSquare() {
218 if (!CurrentToken)
219 return false;
220
Alexander Kornienkod71b15b2013-06-17 13:19:53 +0000221 // A '[' could be an index subscript (after an identifier or after
Nico Weber051860e2013-02-10 02:08:05 +0000222 // ')' or ']'), it could be the start of an Objective-C method
223 // expression, or it could the the start of an Objective-C array literal.
Manuel Klimekb3987012013-05-29 14:47:47 +0000224 FormatToken *Left = CurrentToken->Previous;
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000225 FormatToken *Parent = Left->getPreviousNonComment();
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000226 bool StartsObjCMethodExpr =
Daniel Jasper567dcf92013-09-05 09:29:45 +0000227 Contexts.back().CanBeExpression && Left->Type != TT_LambdaLSquare &&
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700228 CurrentToken->isNot(tok::l_brace) &&
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000229 (!Parent || Parent->isOneOf(tok::colon, tok::l_square, tok::l_paren,
230 tok::kw_return, tok::kw_throw) ||
Daniel Jasperac3223e2013-04-10 09:49:49 +0000231 Parent->isUnaryOperator() || Parent->Type == TT_ObjCForIn ||
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000232 Parent->Type == TT_CastRParen ||
Manuel Klimekb3987012013-05-29 14:47:47 +0000233 getBinOpPrecedence(Parent->Tok.getKind(), true, true) > prec::Unknown);
Daniel Jasper923ebef2013-03-14 13:45:21 +0000234 ScopedContextCreator ContextCreator(*this, tok::l_square, 10);
Daniel Jasper6f21a982013-03-13 07:49:51 +0000235 Contexts.back().IsExpression = true;
Daniel Jasper8f54d882013-10-26 17:00:22 +0000236 bool ColonFound = false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000237
Daniel Jasper4e778092013-02-06 10:05:46 +0000238 if (StartsObjCMethodExpr) {
239 Contexts.back().ColonIsObjCMethodExpr = true;
240 Left->Type = TT_ObjCMethodExpr;
Daniel Jaspera07aa662013-10-22 15:30:28 +0000241 } else if (Parent && Parent->is(tok::at)) {
242 Left->Type = TT_ArrayInitializerLSquare;
243 } else if (Left->Type == TT_Unknown) {
244 Left->Type = TT_ArraySubscriptLSquare;
Daniel Jasper4e778092013-02-06 10:05:46 +0000245 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000246
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700247 while (CurrentToken) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000248 if (CurrentToken->is(tok::r_square)) {
Daniel Jasperac2c9742013-09-05 10:04:31 +0000249 if (CurrentToken->Next && CurrentToken->Next->is(tok::l_paren) &&
250 Left->Type == TT_ObjCMethodExpr) {
Nico Webere8a97982013-02-06 06:20:11 +0000251 // An ObjC method call is rarely followed by an open parenthesis.
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000252 // FIXME: Do we incorrectly label ":" with this?
253 StartsObjCMethodExpr = false;
254 Left->Type = TT_Unknown;
255 }
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700256 if (StartsObjCMethodExpr && CurrentToken->Previous != Left) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000257 CurrentToken->Type = TT_ObjCMethodExpr;
Nico Webere8a97982013-02-06 06:20:11 +0000258 // determineStarAmpUsage() thinks that '*' '[' is allocating an
259 // array of pointers, but if '[' starts a selector then '*' is a
260 // binary operator.
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700261 if (Parent && Parent->Type == TT_PointerOrReference)
Nico Weber4ed7f3e2013-02-06 16:54:35 +0000262 Parent->Type = TT_BinaryOperator;
Daniel Jasper01786732013-02-04 07:21:18 +0000263 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000264 Left->MatchingParen = CurrentToken;
265 CurrentToken->MatchingParen = Left;
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700266 if (Contexts.back().FirstObjCSelectorName) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000267 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
268 Contexts.back().LongestObjCSelectorName;
Stephen Hines651f13c2014-04-23 16:59:28 -0700269 if (Contexts.back().NumBlockParameters > 1)
270 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = 0;
271 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000272 next();
273 return true;
274 }
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000275 if (CurrentToken->isOneOf(tok::r_paren, tok::r_brace))
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000276 return false;
Daniel Jasper8f54d882013-10-26 17:00:22 +0000277 if (CurrentToken->is(tok::colon))
278 ColonFound = true;
Daniel Jaspera07aa662013-10-22 15:30:28 +0000279 if (CurrentToken->is(tok::comma) &&
Stephen Hines651f13c2014-04-23 16:59:28 -0700280 Style.Language != FormatStyle::LK_Proto &&
Daniel Jasper3c6aea72013-10-24 10:31:50 +0000281 (Left->Type == TT_ArraySubscriptLSquare ||
Daniel Jasper8f54d882013-10-26 17:00:22 +0000282 (Left->Type == TT_ObjCMethodExpr && !ColonFound)))
Daniel Jaspera07aa662013-10-22 15:30:28 +0000283 Left->Type = TT_ArrayInitializerLSquare;
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000284 updateParameterCount(Left, CurrentToken);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000285 if (!consumeToken())
286 return false;
287 }
288 return false;
289 }
290
291 bool parseBrace() {
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700292 if (CurrentToken) {
Manuel Klimekb3987012013-05-29 14:47:47 +0000293 FormatToken *Left = CurrentToken->Previous;
Stephen Hines651f13c2014-04-23 16:59:28 -0700294
295 if (Contexts.back().CaretFound)
296 Left->Type = TT_ObjCBlockLBrace;
297 Contexts.back().CaretFound = false;
298
Daniel Jasper3c6aea72013-10-24 10:31:50 +0000299 ScopedContextCreator ContextCreator(*this, tok::l_brace, 1);
300 Contexts.back().ColonIsDictLiteral = true;
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700301 if (Left->BlockKind == BK_BracedInit)
302 Contexts.back().IsExpression = true;
Nico Weberf2ff8122013-05-26 05:39:26 +0000303
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700304 while (CurrentToken) {
Daniel Jasper53e72cd2013-05-06 08:27:33 +0000305 if (CurrentToken->is(tok::r_brace)) {
306 Left->MatchingParen = CurrentToken;
307 CurrentToken->MatchingParen = Left;
308 next();
309 return true;
310 }
311 if (CurrentToken->isOneOf(tok::r_paren, tok::r_square))
312 return false;
313 updateParameterCount(Left, CurrentToken);
Stephen Hines651f13c2014-04-23 16:59:28 -0700314 if (CurrentToken->is(tok::colon) &&
315 Style.Language != FormatStyle::LK_Proto)
Daniel Jasper3c6aea72013-10-24 10:31:50 +0000316 Left->Type = TT_DictLiteral;
Daniel Jasper53e72cd2013-05-06 08:27:33 +0000317 if (!consumeToken())
318 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000319 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000320 }
Daniel Jasper53e72cd2013-05-06 08:27:33 +0000321 // No closing "}" found, this probably starts a definition.
322 Line.StartsDefinition = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000323 return true;
324 }
Daniel Jasperc4615b72013-02-20 12:56:39 +0000325
Manuel Klimekb3987012013-05-29 14:47:47 +0000326 void updateParameterCount(FormatToken *Left, FormatToken *Current) {
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000327 if (Current->is(tok::comma)) {
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000328 ++Left->ParameterCount;
Daniel Jasperd4a03db2013-08-22 15:00:41 +0000329 if (!Left->Role)
330 Left->Role.reset(new CommaSeparatedList(Style));
331 Left->Role->CommaFound(Current);
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000332 } else if (Left->ParameterCount == 0 && Current->isNot(tok::comment)) {
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000333 Left->ParameterCount = 1;
Daniel Jasperc7bd68f2013-07-10 14:02:49 +0000334 }
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000335 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000336
337 bool parseConditional() {
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700338 while (CurrentToken) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000339 if (CurrentToken->is(tok::colon)) {
340 CurrentToken->Type = TT_ConditionalExpr;
341 next();
342 return true;
343 }
344 if (!consumeToken())
345 return false;
346 }
347 return false;
348 }
349
350 bool parseTemplateDeclaration() {
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700351 if (CurrentToken && CurrentToken->is(tok::less)) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000352 CurrentToken->Type = TT_TemplateOpener;
353 next();
354 if (!parseAngle())
355 return false;
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700356 if (CurrentToken)
Manuel Klimekb3987012013-05-29 14:47:47 +0000357 CurrentToken->Previous->ClosesTemplateDeclaration = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000358 return true;
359 }
360 return false;
361 }
362
363 bool consumeToken() {
Manuel Klimekb3987012013-05-29 14:47:47 +0000364 FormatToken *Tok = CurrentToken;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000365 next();
Manuel Klimekb3987012013-05-29 14:47:47 +0000366 switch (Tok->Tok.getKind()) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000367 case tok::plus:
368 case tok::minus:
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700369 if (!Tok->Previous && Line.MustBeDeclaration)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000370 Tok->Type = TT_ObjCMethodSpecifier;
371 break;
372 case tok::colon:
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700373 if (!Tok->Previous)
Daniel Jaspercf6d76a2013-03-18 12:50:26 +0000374 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000375 // Colons from ?: are handled in parseConditional().
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700376 if (Tok->Previous->is(tok::r_paren) && Contexts.size() == 1 &&
377 Line.First->isNot(tok::kw_case)) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000378 Tok->Type = TT_CtorInitializerColon;
Daniel Jasper3c6aea72013-10-24 10:31:50 +0000379 } else if (Contexts.back().ColonIsDictLiteral) {
380 Tok->Type = TT_DictLiteral;
Daniel Jasper4e778092013-02-06 10:05:46 +0000381 } else if (Contexts.back().ColonIsObjCMethodExpr ||
Manuel Klimekb3987012013-05-29 14:47:47 +0000382 Line.First->Type == TT_ObjCMethodSpecifier) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000383 Tok->Type = TT_ObjCMethodExpr;
Manuel Klimekb3987012013-05-29 14:47:47 +0000384 Tok->Previous->Type = TT_ObjCSelectorName;
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +0000385 if (Tok->Previous->ColumnWidth >
Alexander Kornienko00895102013-06-05 14:09:10 +0000386 Contexts.back().LongestObjCSelectorName) {
Alexander Kornienko01fe9f92013-10-10 13:36:20 +0000387 Contexts.back().LongestObjCSelectorName = Tok->Previous->ColumnWidth;
Alexander Kornienko00895102013-06-05 14:09:10 +0000388 }
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700389 if (!Contexts.back().FirstObjCSelectorName)
Manuel Klimekb3987012013-05-29 14:47:47 +0000390 Contexts.back().FirstObjCSelectorName = Tok->Previous;
Daniel Jasper4e778092013-02-06 10:05:46 +0000391 } else if (Contexts.back().ColonIsForRangeExpr) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000392 Tok->Type = TT_RangeBasedForLoopColon;
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700393 } else if (CurrentToken && CurrentToken->is(tok::numeric_constant)) {
Alexander Kornienko01fe9f92013-10-10 13:36:20 +0000394 Tok->Type = TT_BitFieldColon;
Daniel Jaspercea014b2013-10-08 16:24:07 +0000395 } else if (Contexts.size() == 1 && Line.First->isNot(tok::kw_enum)) {
Daniel Jasper6cabab42013-02-14 08:42:54 +0000396 Tok->Type = TT_InheritanceColon;
Daniel Jasper923ebef2013-03-14 13:45:21 +0000397 } else if (Contexts.back().ContextKind == tok::l_paren) {
398 Tok->Type = TT_InlineASMColon;
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000399 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000400 break;
401 case tok::kw_if:
402 case tok::kw_while:
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700403 if (CurrentToken && CurrentToken->is(tok::l_paren)) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000404 next();
Nico Weber27268772013-06-26 00:30:14 +0000405 if (!parseParens(/*LookForDecls=*/true))
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000406 return false;
407 }
408 break;
409 case tok::kw_for:
Daniel Jasper4e778092013-02-06 10:05:46 +0000410 Contexts.back().ColonIsForRangeExpr = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000411 next();
412 if (!parseParens())
413 return false;
414 break;
415 case tok::l_paren:
416 if (!parseParens())
417 return false;
Daniel Jasper59875ac2013-11-07 17:43:07 +0000418 if (Line.MustBeDeclaration && Contexts.size() == 1 &&
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700419 !Contexts.back().IsExpression &&
420 Line.First->Type != TT_ObjCProperty &&
421 (!Tok->Previous || Tok->Previous->isNot(tok::kw_decltype)))
Daniel Jasper3c08a812013-02-24 18:54:32 +0000422 Line.MightBeFunctionDecl = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000423 break;
424 case tok::l_square:
425 if (!parseSquare())
426 return false;
427 break;
428 case tok::l_brace:
429 if (!parseBrace())
430 return false;
431 break;
432 case tok::less:
Daniel Jasper0236dd02013-07-30 22:37:19 +0000433 if (Tok->Previous && !Tok->Previous->Tok.isLiteral() && parseAngle())
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000434 Tok->Type = TT_TemplateOpener;
435 else {
436 Tok->Type = TT_BinaryOperator;
437 CurrentToken = Tok;
438 next();
439 }
440 break;
441 case tok::r_paren:
442 case tok::r_square:
443 return false;
444 case tok::r_brace:
445 // Lines can start with '}'.
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700446 if (Tok->Previous)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000447 return false;
448 break;
449 case tok::greater:
450 Tok->Type = TT_BinaryOperator;
451 break;
452 case tok::kw_operator:
Daniel Jasper174f60f2013-09-02 09:20:39 +0000453 while (CurrentToken &&
454 !CurrentToken->isOneOf(tok::l_paren, tok::semi, tok::r_paren)) {
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000455 if (CurrentToken->isOneOf(tok::star, tok::amp))
Daniel Jasper2b4c9242013-02-11 08:01:18 +0000456 CurrentToken->Type = TT_PointerOrReference;
457 consumeToken();
Daniel Jasper174f60f2013-09-02 09:20:39 +0000458 if (CurrentToken && CurrentToken->Previous->Type == TT_BinaryOperator)
Daniel Jasperc476ea92013-08-28 07:27:35 +0000459 CurrentToken->Previous->Type = TT_OverloadedOperator;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000460 }
Daniel Jasper6ea933c2013-05-10 07:59:58 +0000461 if (CurrentToken) {
Daniel Jasper2b4c9242013-02-11 08:01:18 +0000462 CurrentToken->Type = TT_OverloadedOperatorLParen;
Manuel Klimekb3987012013-05-29 14:47:47 +0000463 if (CurrentToken->Previous->Type == TT_BinaryOperator)
464 CurrentToken->Previous->Type = TT_OverloadedOperator;
Daniel Jasper6ea933c2013-05-10 07:59:58 +0000465 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000466 break;
467 case tok::question:
468 parseConditional();
469 break;
470 case tok::kw_template:
471 parseTemplateDeclaration();
472 break;
Nico Weberc2e6d2a2013-02-11 15:32:15 +0000473 case tok::identifier:
Manuel Klimekb3987012013-05-29 14:47:47 +0000474 if (Line.First->is(tok::kw_for) &&
475 Tok->Tok.getIdentifierInfo() == &Ident_in)
Nico Weberc2e6d2a2013-02-11 15:32:15 +0000476 Tok->Type = TT_ObjCForIn;
477 break;
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000478 case tok::comma:
479 if (Contexts.back().FirstStartOfName)
480 Contexts.back().FirstStartOfName->PartOfMultiVariableDeclStmt = true;
Daniel Jaspere8b10d32013-07-26 16:56:36 +0000481 if (Contexts.back().InCtorInitializer)
482 Tok->Type = TT_CtorInitializerComma;
Stephen Hines651f13c2014-04-23 16:59:28 -0700483 if (Contexts.back().IsForEachMacro)
484 Contexts.back().IsExpression = true;
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000485 break;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000486 default:
487 break;
488 }
489 return true;
490 }
491
492 void parseIncludeDirective() {
493 next();
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700494 if (CurrentToken && CurrentToken->is(tok::less)) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000495 next();
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700496 while (CurrentToken) {
Manuel Klimekb3987012013-05-29 14:47:47 +0000497 if (CurrentToken->isNot(tok::comment) || CurrentToken->Next)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000498 CurrentToken->Type = TT_ImplicitStringLiteral;
499 next();
500 }
501 } else {
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700502 while (CurrentToken) {
Daniel Jasper3a204412013-02-23 07:46:38 +0000503 if (CurrentToken->is(tok::string_literal))
504 // Mark these string literals as "implicit" literals, too, so that
505 // they are not split or line-wrapped.
506 CurrentToken->Type = TT_ImplicitStringLiteral;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000507 next();
508 }
509 }
510 }
511
512 void parseWarningOrError() {
513 next();
514 // We still want to format the whitespace left of the first token of the
515 // warning or error.
516 next();
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700517 while (CurrentToken) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000518 CurrentToken->Type = TT_ImplicitStringLiteral;
519 next();
520 }
521 }
522
Stephen Hines651f13c2014-04-23 16:59:28 -0700523 void parsePragma() {
524 next(); // Consume "pragma".
525 if (CurrentToken && CurrentToken->TokenText == "mark") {
526 next(); // Consume "mark".
527 next(); // Consume first token (so we fix leading whitespace).
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700528 while (CurrentToken) {
Stephen Hines651f13c2014-04-23 16:59:28 -0700529 CurrentToken->Type = TT_ImplicitStringLiteral;
530 next();
531 }
532 }
533 }
534
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000535 void parsePreprocessorDirective() {
536 next();
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700537 if (!CurrentToken)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000538 return;
Alexander Kornienkob18c2582013-10-11 21:43:05 +0000539 if (CurrentToken->Tok.is(tok::numeric_constant)) {
540 CurrentToken->SpacesRequiredBefore = 1;
541 return;
542 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000543 // Hashes in the middle of a line can lead to any strange token
544 // sequence.
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700545 if (!CurrentToken->Tok.getIdentifierInfo())
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000546 return;
Manuel Klimekb3987012013-05-29 14:47:47 +0000547 switch (CurrentToken->Tok.getIdentifierInfo()->getPPKeywordID()) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000548 case tok::pp_include:
549 case tok::pp_import:
550 parseIncludeDirective();
551 break;
552 case tok::pp_error:
553 case tok::pp_warning:
554 parseWarningOrError();
555 break;
Stephen Hines651f13c2014-04-23 16:59:28 -0700556 case tok::pp_pragma:
557 parsePragma();
558 break;
Daniel Jasperaae7bad2013-04-23 13:54:04 +0000559 case tok::pp_if:
560 case tok::pp_elif:
Stephen Hines651f13c2014-04-23 16:59:28 -0700561 Contexts.back().IsExpression = true;
Daniel Jasperaae7bad2013-04-23 13:54:04 +0000562 parseLine();
563 break;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000564 default:
565 break;
566 }
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700567 while (CurrentToken)
Daniel Jasper5b7e7b02013-02-05 09:34:14 +0000568 next();
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000569 }
570
Nico Weber95e8e462013-02-12 16:17:07 +0000571public:
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000572 LineType parseLine() {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000573 if (CurrentToken->is(tok::hash)) {
574 parsePreprocessorDirective();
575 return LT_PreprocessorDirective;
576 }
Stephen Hines651f13c2014-04-23 16:59:28 -0700577
578 // Directly allow to 'import <string-literal>' to support protocol buffer
579 // definitions (code.google.com/p/protobuf) or missing "#" (either way we
580 // should not break the line).
581 IdentifierInfo *Info = CurrentToken->Tok.getIdentifierInfo();
582 if (Info && Info->getPPKeywordID() == tok::pp_import &&
583 CurrentToken->Next && CurrentToken->Next->is(tok::string_literal))
584 parseIncludeDirective();
585
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700586 while (CurrentToken) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000587 if (CurrentToken->is(tok::kw_virtual))
588 KeywordVirtualFound = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000589 if (!consumeToken())
590 return LT_Invalid;
591 }
592 if (KeywordVirtualFound)
593 return LT_VirtualFunctionDecl;
594
Manuel Klimekb3987012013-05-29 14:47:47 +0000595 if (Line.First->Type == TT_ObjCMethodSpecifier) {
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700596 if (Contexts.back().FirstObjCSelectorName)
Daniel Jasper4e778092013-02-06 10:05:46 +0000597 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
598 Contexts.back().LongestObjCSelectorName;
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000599 return LT_ObjCMethodDecl;
600 }
601
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000602 return LT_Other;
603 }
604
Nico Weber95e8e462013-02-12 16:17:07 +0000605private:
Stephen Hines651f13c2014-04-23 16:59:28 -0700606 void resetTokenMetadata(FormatToken *Token) {
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700607 if (!Token)
608 return;
Stephen Hines651f13c2014-04-23 16:59:28 -0700609
610 // Reset token type in case we have already looked at it and then
611 // recovered from an error (e.g. failure to find the matching >).
612 if (CurrentToken->Type != TT_LambdaLSquare &&
613 CurrentToken->Type != TT_FunctionLBrace &&
614 CurrentToken->Type != TT_ImplicitStringLiteral &&
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700615 CurrentToken->Type != TT_RegexLiteral &&
Stephen Hines651f13c2014-04-23 16:59:28 -0700616 CurrentToken->Type != TT_TrailingReturnArrow)
617 CurrentToken->Type = TT_Unknown;
618 if (CurrentToken->Role)
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700619 CurrentToken->Role.reset(nullptr);
Stephen Hines651f13c2014-04-23 16:59:28 -0700620 CurrentToken->FakeLParens.clear();
621 CurrentToken->FakeRParens = 0;
622 }
623
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000624 void next() {
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700625 if (CurrentToken) {
Daniel Jasper01786732013-02-04 07:21:18 +0000626 determineTokenType(*CurrentToken);
Daniel Jasper4e778092013-02-06 10:05:46 +0000627 CurrentToken->BindingStrength = Contexts.back().BindingStrength;
Stephen Hines651f13c2014-04-23 16:59:28 -0700628 CurrentToken->NestingLevel = Contexts.size() - 1;
Manuel Klimekb3987012013-05-29 14:47:47 +0000629 CurrentToken = CurrentToken->Next;
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700630 }
Daniel Jasperd0f349b2013-02-18 12:44:35 +0000631
Stephen Hines651f13c2014-04-23 16:59:28 -0700632 resetTokenMetadata(CurrentToken);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000633 }
634
Daniel Jasper4e778092013-02-06 10:05:46 +0000635 /// \brief A struct to hold information valid in a specific context, e.g.
636 /// a pair of parenthesis.
637 struct Context {
Daniel Jasper923ebef2013-03-14 13:45:21 +0000638 Context(tok::TokenKind ContextKind, unsigned BindingStrength,
639 bool IsExpression)
640 : ContextKind(ContextKind), BindingStrength(BindingStrength),
Stephen Hines651f13c2014-04-23 16:59:28 -0700641 LongestObjCSelectorName(0), NumBlockParameters(0),
642 ColonIsForRangeExpr(false), ColonIsDictLiteral(false),
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700643 ColonIsObjCMethodExpr(false), FirstObjCSelectorName(nullptr),
644 FirstStartOfName(nullptr), IsExpression(IsExpression),
Stephen Hines651f13c2014-04-23 16:59:28 -0700645 CanBeExpression(true), InTemplateArgument(false),
646 InCtorInitializer(false), CaretFound(false), IsForEachMacro(false) {}
Daniel Jasper01786732013-02-04 07:21:18 +0000647
Daniel Jasper923ebef2013-03-14 13:45:21 +0000648 tok::TokenKind ContextKind;
Daniel Jasper4e778092013-02-06 10:05:46 +0000649 unsigned BindingStrength;
650 unsigned LongestObjCSelectorName;
Stephen Hines651f13c2014-04-23 16:59:28 -0700651 unsigned NumBlockParameters;
Daniel Jasper4e778092013-02-06 10:05:46 +0000652 bool ColonIsForRangeExpr;
Daniel Jasper3c6aea72013-10-24 10:31:50 +0000653 bool ColonIsDictLiteral;
Daniel Jasper4e778092013-02-06 10:05:46 +0000654 bool ColonIsObjCMethodExpr;
Manuel Klimekb3987012013-05-29 14:47:47 +0000655 FormatToken *FirstObjCSelectorName;
656 FormatToken *FirstStartOfName;
Daniel Jasper4e778092013-02-06 10:05:46 +0000657 bool IsExpression;
Daniel Jasper6f21a982013-03-13 07:49:51 +0000658 bool CanBeExpression;
Stephen Hines651f13c2014-04-23 16:59:28 -0700659 bool InTemplateArgument;
Daniel Jaspere8b10d32013-07-26 16:56:36 +0000660 bool InCtorInitializer;
Stephen Hines651f13c2014-04-23 16:59:28 -0700661 bool CaretFound;
662 bool IsForEachMacro;
Daniel Jasper4e778092013-02-06 10:05:46 +0000663 };
664
665 /// \brief Puts a new \c Context onto the stack \c Contexts for the lifetime
666 /// of each instance.
667 struct ScopedContextCreator {
668 AnnotatingParser &P;
669
Daniel Jasper923ebef2013-03-14 13:45:21 +0000670 ScopedContextCreator(AnnotatingParser &P, tok::TokenKind ContextKind,
671 unsigned Increase)
672 : P(P) {
Daniel Jasper2a409b62013-07-08 14:34:09 +0000673 P.Contexts.push_back(Context(ContextKind,
674 P.Contexts.back().BindingStrength + Increase,
675 P.Contexts.back().IsExpression));
Daniel Jasper4e778092013-02-06 10:05:46 +0000676 }
677
678 ~ScopedContextCreator() { P.Contexts.pop_back(); }
679 };
Daniel Jasper01786732013-02-04 07:21:18 +0000680
Manuel Klimekb3987012013-05-29 14:47:47 +0000681 void determineTokenType(FormatToken &Current) {
682 if (Current.getPrecedence() == prec::Assignment &&
Daniel Jasper53352602013-08-12 12:16:34 +0000683 !Line.First->isOneOf(tok::kw_template, tok::kw_using) &&
Manuel Klimekb3987012013-05-29 14:47:47 +0000684 (!Current.Previous || Current.Previous->isNot(tok::kw_operator))) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000685 Contexts.back().IsExpression = true;
Manuel Klimekb3987012013-05-29 14:47:47 +0000686 for (FormatToken *Previous = Current.Previous;
Daniel Jasper7e274002013-09-11 20:37:10 +0000687 Previous && !Previous->isOneOf(tok::comma, tok::semi);
Manuel Klimekb3987012013-05-29 14:47:47 +0000688 Previous = Previous->Previous) {
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700689 if (Previous->isOneOf(tok::r_square, tok::r_paren))
Daniel Jasper9c65b062013-02-27 11:43:50 +0000690 Previous = Previous->MatchingParen;
Daniel Jasper01786732013-02-04 07:21:18 +0000691 if (Previous->Type == TT_BinaryOperator &&
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000692 Previous->isOneOf(tok::star, tok::amp)) {
Daniel Jasper01786732013-02-04 07:21:18 +0000693 Previous->Type = TT_PointerOrReference;
694 }
Daniel Jasper01786732013-02-04 07:21:18 +0000695 }
Stephen Hines651f13c2014-04-23 16:59:28 -0700696 } else if (Current.isOneOf(tok::kw_return, tok::kw_throw)) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000697 Contexts.back().IsExpression = true;
Stephen Hines651f13c2014-04-23 16:59:28 -0700698 } else if (Current.is(tok::l_paren) && !Line.MustBeDeclaration &&
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700699 !Line.InPPDirective &&
700 (!Current.Previous ||
701 Current.Previous->isNot(tok::kw_decltype))) {
Stephen Hines651f13c2014-04-23 16:59:28 -0700702 bool ParametersOfFunctionType =
703 Current.Previous && Current.Previous->is(tok::r_paren) &&
704 Current.Previous->MatchingParen &&
705 Current.Previous->MatchingParen->Type == TT_FunctionTypeLParen;
706 bool IsForOrCatch = Current.Previous &&
707 Current.Previous->isOneOf(tok::kw_for, tok::kw_catch);
708 Contexts.back().IsExpression = !ParametersOfFunctionType && !IsForOrCatch;
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000709 } else if (Current.isOneOf(tok::r_paren, tok::greater, tok::comma)) {
Manuel Klimekb3987012013-05-29 14:47:47 +0000710 for (FormatToken *Previous = Current.Previous;
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000711 Previous && Previous->isOneOf(tok::star, tok::amp);
Manuel Klimekb3987012013-05-29 14:47:47 +0000712 Previous = Previous->Previous)
Nico Weber95e8e462013-02-12 16:17:07 +0000713 Previous->Type = TT_PointerOrReference;
Manuel Klimekb3987012013-05-29 14:47:47 +0000714 } else if (Current.Previous &&
715 Current.Previous->Type == TT_CtorInitializerColon) {
Daniel Jasperd0f349b2013-02-18 12:44:35 +0000716 Contexts.back().IsExpression = true;
Daniel Jaspere8b10d32013-07-26 16:56:36 +0000717 Contexts.back().InCtorInitializer = true;
Daniel Jasper6f21a982013-03-13 07:49:51 +0000718 } else if (Current.is(tok::kw_new)) {
719 Contexts.back().CanBeExpression = false;
Daniel Jasperf9504aa2013-11-07 19:56:07 +0000720 } else if (Current.is(tok::semi) || Current.is(tok::exclaim)) {
Daniel Jasper16a69ef2013-05-03 14:41:24 +0000721 // This should be the condition or increment in a for-loop.
722 Contexts.back().IsExpression = true;
Nico Weber95e8e462013-02-12 16:17:07 +0000723 }
Daniel Jasper01786732013-02-04 07:21:18 +0000724
725 if (Current.Type == TT_Unknown) {
Daniel Jasper6b3ff8c2013-09-27 08:29:16 +0000726 // Line.MightBeFunctionDecl can only be true after the parentheses of a
727 // function declaration have been found. In this case, 'Current' is a
728 // trailing token of this declaration and thus cannot be a name.
729 if (isStartOfName(Current) && !Line.MightBeFunctionDecl) {
Daniel Jasper8ed9f2b2013-04-03 13:36:17 +0000730 Contexts.back().FirstStartOfName = &Current;
Daniel Jasper3c08a812013-02-24 18:54:32 +0000731 Current.Type = TT_StartOfName;
Daniel Jasper2ca37412013-07-09 14:36:48 +0000732 } else if (Current.is(tok::kw_auto)) {
733 AutoFound = true;
Daniel Jasper3262f4c2013-07-11 14:33:06 +0000734 } else if (Current.is(tok::arrow) && AutoFound &&
735 Line.MustBeDeclaration) {
Daniel Jasper2ca37412013-07-09 14:36:48 +0000736 Current.Type = TT_TrailingReturnArrow;
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000737 } else if (Current.isOneOf(tok::star, tok::amp, tok::ampamp)) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000738 Current.Type =
Daniel Jasperd6104f62013-07-05 13:30:40 +0000739 determineStarAmpUsage(Current, Contexts.back().CanBeExpression &&
Stephen Hines651f13c2014-04-23 16:59:28 -0700740 Contexts.back().IsExpression,
741 Contexts.back().InTemplateArgument);
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000742 } else if (Current.isOneOf(tok::minus, tok::plus, tok::caret)) {
Daniel Jasper01786732013-02-04 07:21:18 +0000743 Current.Type = determinePlusMinusCaretUsage(Current);
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700744 if (Current.Type == TT_UnaryOperator && Current.is(tok::caret)) {
Stephen Hines651f13c2014-04-23 16:59:28 -0700745 ++Contexts.back().NumBlockParameters;
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700746 Contexts.back().CaretFound = true;
Stephen Hines651f13c2014-04-23 16:59:28 -0700747 }
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000748 } else if (Current.isOneOf(tok::minusminus, tok::plusplus)) {
Daniel Jasper01786732013-02-04 07:21:18 +0000749 Current.Type = determineIncrementUsage(Current);
750 } else if (Current.is(tok::exclaim)) {
751 Current.Type = TT_UnaryOperator;
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700752 } else if (Current.is(tok::question)) {
753 Current.Type = TT_ConditionalExpr;
Manuel Klimek31e44f72013-09-04 08:20:47 +0000754 } else if (Current.isBinaryOperator() &&
755 (!Current.Previous ||
756 Current.Previous->isNot(tok::l_square))) {
Daniel Jasper01786732013-02-04 07:21:18 +0000757 Current.Type = TT_BinaryOperator;
758 } else if (Current.is(tok::comment)) {
Alexander Kornienko00895102013-06-05 14:09:10 +0000759 if (Current.TokenText.startswith("//"))
Daniel Jasper01786732013-02-04 07:21:18 +0000760 Current.Type = TT_LineComment;
761 else
762 Current.Type = TT_BlockComment;
Nico Weber37d69312013-02-13 04:13:13 +0000763 } else if (Current.is(tok::r_paren)) {
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700764 if (rParenEndsCast(Current))
Nico Weber37d69312013-02-13 04:13:13 +0000765 Current.Type = TT_CastRParen;
Manuel Klimekb3987012013-05-29 14:47:47 +0000766 } else if (Current.is(tok::at) && Current.Next) {
767 switch (Current.Next->Tok.getObjCKeywordID()) {
Daniel Jasper01786732013-02-04 07:21:18 +0000768 case tok::objc_interface:
769 case tok::objc_implementation:
770 case tok::objc_protocol:
771 Current.Type = TT_ObjCDecl;
772 break;
773 case tok::objc_property:
774 Current.Type = TT_ObjCProperty;
775 break;
776 default:
777 break;
778 }
Daniel Jasper5ad390d2013-05-28 11:30:49 +0000779 } else if (Current.is(tok::period)) {
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000780 FormatToken *PreviousNoComment = Current.getPreviousNonComment();
Daniel Jasper5ad390d2013-05-28 11:30:49 +0000781 if (PreviousNoComment &&
782 PreviousNoComment->isOneOf(tok::comma, tok::l_brace))
783 Current.Type = TT_DesignatedInitializerPeriod;
Stephen Hines651f13c2014-04-23 16:59:28 -0700784 } else if (Current.isOneOf(tok::identifier, tok::kw_const) &&
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700785 Current.Previous && Current.Previous->isNot(tok::equal) &&
Stephen Hines651f13c2014-04-23 16:59:28 -0700786 Line.MightBeFunctionDecl && Contexts.size() == 1) {
787 // Line.MightBeFunctionDecl can only be true after the parentheses of a
788 // function declaration have been found.
789 Current.Type = TT_TrailingAnnotation;
Daniel Jasper01786732013-02-04 07:21:18 +0000790 }
791 }
792 }
793
Daniel Jasper6ac431c2013-07-02 09:47:29 +0000794 /// \brief Take a guess at whether \p Tok starts a name of a function or
795 /// variable declaration.
796 ///
797 /// This is a heuristic based on whether \p Tok is an identifier following
798 /// something that is likely a type.
799 bool isStartOfName(const FormatToken &Tok) {
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700800 if (Tok.isNot(tok::identifier) || !Tok.Previous)
Daniel Jasper6ac431c2013-07-02 09:47:29 +0000801 return false;
802
803 // Skip "const" as it does not have an influence on whether this is a name.
804 FormatToken *PreviousNotConst = Tok.Previous;
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700805 while (PreviousNotConst && PreviousNotConst->is(tok::kw_const))
Daniel Jasper6ac431c2013-07-02 09:47:29 +0000806 PreviousNotConst = PreviousNotConst->Previous;
807
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700808 if (!PreviousNotConst)
Daniel Jasper6ac431c2013-07-02 09:47:29 +0000809 return false;
810
Daniel Jasper2a409b62013-07-08 14:34:09 +0000811 bool IsPPKeyword = PreviousNotConst->is(tok::identifier) &&
812 PreviousNotConst->Previous &&
813 PreviousNotConst->Previous->is(tok::hash);
Daniel Jasper6ac431c2013-07-02 09:47:29 +0000814
Daniel Jasper92495a82013-08-19 10:16:18 +0000815 if (PreviousNotConst->Type == TT_TemplateCloser)
816 return PreviousNotConst && PreviousNotConst->MatchingParen &&
817 PreviousNotConst->MatchingParen->Previous &&
818 PreviousNotConst->MatchingParen->Previous->isNot(tok::kw_template);
819
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700820 if (PreviousNotConst->is(tok::r_paren) && PreviousNotConst->MatchingParen &&
821 PreviousNotConst->MatchingParen->Previous &&
822 PreviousNotConst->MatchingParen->Previous->is(tok::kw_decltype))
823 return true;
824
Daniel Jasper6ac431c2013-07-02 09:47:29 +0000825 return (!IsPPKeyword && PreviousNotConst->is(tok::identifier)) ||
826 PreviousNotConst->Type == TT_PointerOrReference ||
Stephen Hines651f13c2014-04-23 16:59:28 -0700827 PreviousNotConst->isSimpleTypeSpecifier();
Daniel Jasper6ac431c2013-07-02 09:47:29 +0000828 }
829
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700830 /// \brief Determine whether ')' is ending a cast.
831 bool rParenEndsCast(const FormatToken &Tok) {
832 FormatToken *LeftOfParens = NULL;
833 if (Tok.MatchingParen)
834 LeftOfParens = Tok.MatchingParen->getPreviousNonComment();
835 bool IsCast = false;
836 bool ParensAreEmpty = Tok.Previous == Tok.MatchingParen;
837 bool ParensAreType = !Tok.Previous ||
838 Tok.Previous->Type == TT_PointerOrReference ||
839 Tok.Previous->Type == TT_TemplateCloser ||
840 Tok.Previous->isSimpleTypeSpecifier();
841 bool ParensCouldEndDecl =
842 Tok.Next && Tok.Next->isOneOf(tok::equal, tok::semi, tok::l_brace);
843 bool IsSizeOfOrAlignOf =
844 LeftOfParens && LeftOfParens->isOneOf(tok::kw_sizeof, tok::kw_alignof);
845 if (ParensAreType && !ParensCouldEndDecl && !IsSizeOfOrAlignOf &&
846 ((Contexts.size() > 1 && Contexts[Contexts.size() - 2].IsExpression) ||
847 (Tok.Next && Tok.Next->isBinaryOperator())))
848 IsCast = true;
849 else if (Tok.Next && Tok.Next->isNot(tok::string_literal) &&
850 (Tok.Next->Tok.isLiteral() ||
851 Tok.Next->isOneOf(tok::kw_sizeof, tok::kw_alignof)))
852 IsCast = true;
853 // If there is an identifier after the (), it is likely a cast, unless
854 // there is also an identifier before the ().
855 else if (LeftOfParens && (LeftOfParens->Tok.getIdentifierInfo() == NULL ||
856 LeftOfParens->is(tok::kw_return)) &&
857 LeftOfParens->Type != TT_OverloadedOperator &&
858 LeftOfParens->isNot(tok::at) &&
859 LeftOfParens->Type != TT_TemplateCloser && Tok.Next) {
860 if (Tok.Next->isOneOf(tok::identifier, tok::numeric_constant)) {
861 IsCast = true;
862 } else {
863 // Use heuristics to recognize c style casting.
864 FormatToken *Prev = Tok.Previous;
865 if (Prev && Prev->isOneOf(tok::amp, tok::star))
866 Prev = Prev->Previous;
867
868 if (Prev && Tok.Next && Tok.Next->Next) {
869 bool NextIsUnary = Tok.Next->isUnaryOperator() ||
870 Tok.Next->isOneOf(tok::amp, tok::star);
871 IsCast = NextIsUnary && Tok.Next->Next->isOneOf(
872 tok::identifier, tok::numeric_constant);
873 }
874
875 for (; Prev != Tok.MatchingParen; Prev = Prev->Previous) {
876 if (!Prev || !Prev->isOneOf(tok::kw_const, tok::identifier)) {
877 IsCast = false;
878 break;
879 }
880 }
881 }
882 }
883 return IsCast && !ParensAreEmpty;
884 }
885
Daniel Jasper01786732013-02-04 07:21:18 +0000886 /// \brief Return the type of the given token assuming it is * or &.
Stephen Hines651f13c2014-04-23 16:59:28 -0700887 TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression,
888 bool InTemplateArgument) {
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000889 const FormatToken *PrevToken = Tok.getPreviousNonComment();
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700890 if (!PrevToken)
Daniel Jasper01786732013-02-04 07:21:18 +0000891 return TT_UnaryOperator;
892
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000893 const FormatToken *NextToken = Tok.getNextNonComment();
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700894 if (!NextToken)
Daniel Jasper01786732013-02-04 07:21:18 +0000895 return TT_Unknown;
896
Daniel Jasper431f5912013-05-28 08:33:00 +0000897 if (PrevToken->is(tok::coloncolon) ||
898 (PrevToken->is(tok::l_paren) && !IsExpression))
Daniel Jasper8a5d7cd2013-03-01 17:13:29 +0000899 return TT_PointerOrReference;
900
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000901 if (PrevToken->isOneOf(tok::l_paren, tok::l_square, tok::l_brace,
Daniel Jasperd3cf17b2013-03-14 10:50:25 +0000902 tok::comma, tok::semi, tok::kw_return, tok::colon,
Daniel Jasper65da8e92013-09-21 17:31:51 +0000903 tok::equal, tok::kw_delete, tok::kw_sizeof) ||
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000904 PrevToken->Type == TT_BinaryOperator ||
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700905 PrevToken->Type == TT_ConditionalExpr ||
Daniel Jasper01786732013-02-04 07:21:18 +0000906 PrevToken->Type == TT_UnaryOperator || PrevToken->Type == TT_CastRParen)
907 return TT_UnaryOperator;
908
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700909 if (NextToken->is(tok::l_square) && NextToken->Type != TT_LambdaLSquare)
Nico Webere8a97982013-02-06 06:20:11 +0000910 return TT_PointerOrReference;
911
Daniel Jasperdb8afe42013-09-10 10:26:38 +0000912 if (PrevToken->is(tok::r_paren) && PrevToken->MatchingParen &&
913 PrevToken->MatchingParen->Previous &&
914 PrevToken->MatchingParen->Previous->is(tok::kw_typeof))
915 return TT_PointerOrReference;
916
Manuel Klimekb3987012013-05-29 14:47:47 +0000917 if (PrevToken->Tok.isLiteral() ||
Stephen Hines651f13c2014-04-23 16:59:28 -0700918 PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::kw_true,
919 tok::kw_false) ||
920 NextToken->Tok.isLiteral() ||
921 NextToken->isOneOf(tok::kw_true, tok::kw_false) ||
922 NextToken->isUnaryOperator() ||
923 // If we know we're in a template argument, there are no named
924 // declarations. Thus, having an identifier on the right-hand side
925 // indicates a binary operator.
926 (InTemplateArgument && NextToken->Tok.isAnyIdentifier()))
Daniel Jasper01786732013-02-04 07:21:18 +0000927 return TT_BinaryOperator;
928
Daniel Jasper01786732013-02-04 07:21:18 +0000929 // It is very unlikely that we are going to find a pointer or reference type
930 // definition on the RHS of an assignment.
931 if (IsExpression)
932 return TT_BinaryOperator;
933
934 return TT_PointerOrReference;
935 }
936
Manuel Klimekb3987012013-05-29 14:47:47 +0000937 TokenType determinePlusMinusCaretUsage(const FormatToken &Tok) {
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000938 const FormatToken *PrevToken = Tok.getPreviousNonComment();
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700939 if (!PrevToken || PrevToken->Type == TT_CastRParen)
Daniel Jasper01786732013-02-04 07:21:18 +0000940 return TT_UnaryOperator;
941
942 // Use heuristics to recognize unary operators.
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000943 if (PrevToken->isOneOf(tok::equal, tok::l_paren, tok::comma, tok::l_square,
944 tok::question, tok::colon, tok::kw_return,
945 tok::kw_case, tok::at, tok::l_brace))
Daniel Jasper01786732013-02-04 07:21:18 +0000946 return TT_UnaryOperator;
947
Nico Weberee0feec2013-02-05 16:21:00 +0000948 // There can't be two consecutive binary operators.
Daniel Jasper01786732013-02-04 07:21:18 +0000949 if (PrevToken->Type == TT_BinaryOperator)
950 return TT_UnaryOperator;
951
952 // Fall back to marking the token as binary operator.
953 return TT_BinaryOperator;
954 }
955
956 /// \brief Determine whether ++/-- are pre- or post-increments/-decrements.
Manuel Klimekb3987012013-05-29 14:47:47 +0000957 TokenType determineIncrementUsage(const FormatToken &Tok) {
Alexander Kornienko0bdc6432013-07-04 14:47:51 +0000958 const FormatToken *PrevToken = Tok.getPreviousNonComment();
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700959 if (!PrevToken || PrevToken->Type == TT_CastRParen)
Daniel Jasper01786732013-02-04 07:21:18 +0000960 return TT_UnaryOperator;
Alexander Kornienkoe74de282013-03-13 14:41:29 +0000961 if (PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::identifier))
Daniel Jasper01786732013-02-04 07:21:18 +0000962 return TT_TrailingUnaryOperator;
963
964 return TT_UnaryOperator;
965 }
Daniel Jasper4e778092013-02-06 10:05:46 +0000966
967 SmallVector<Context, 8> Contexts;
968
Daniel Jasperd4a03db2013-08-22 15:00:41 +0000969 const FormatStyle &Style;
Daniel Jasper4e778092013-02-06 10:05:46 +0000970 AnnotatedLine &Line;
Manuel Klimekb3987012013-05-29 14:47:47 +0000971 FormatToken *CurrentToken;
Daniel Jasper4e778092013-02-06 10:05:46 +0000972 bool KeywordVirtualFound;
Daniel Jasper2ca37412013-07-09 14:36:48 +0000973 bool AutoFound;
Nico Weberc2e6d2a2013-02-11 15:32:15 +0000974 IdentifierInfo &Ident_in;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000975};
976
Daniel Jasperd489f8c2013-08-27 11:09:05 +0000977static int PrecedenceUnaryOperator = prec::PointerToMember + 1;
978static int PrecedenceArrowAndPeriod = prec::PointerToMember + 2;
979
Daniel Jasper29f123b2013-02-08 15:28:42 +0000980/// \brief Parses binary expressions by inserting fake parenthesis based on
981/// operator precedence.
982class ExpressionParser {
983public:
Daniel Jasper9acb8b42013-06-06 09:11:58 +0000984 ExpressionParser(AnnotatedLine &Line) : Current(Line.First) {
985 // Skip leading "}", e.g. in "} else if (...) {".
986 if (Current->is(tok::r_brace))
987 next();
988 }
Daniel Jasper29f123b2013-02-08 15:28:42 +0000989
990 /// \brief Parse expressions with the given operatore precedence.
Daniel Jasper237d4c12013-02-23 21:01:55 +0000991 void parse(int Precedence = 0) {
Daniel Jasper966e6d32013-11-07 19:23:49 +0000992 // Skip 'return' and ObjC selector colons as they are not part of a binary
993 // expression.
994 while (Current &&
995 (Current->is(tok::kw_return) ||
996 (Current->is(tok::colon) && Current->Type == TT_ObjCMethodExpr)))
Daniel Jasperf78bf4a2013-09-30 08:29:03 +0000997 next();
998
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700999 if (!Current || Precedence > PrecedenceArrowAndPeriod)
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001000 return;
1001
Daniel Jasperc01897c2013-05-31 14:56:12 +00001002 // Conditional expressions need to be parsed separately for proper nesting.
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001003 if (Precedence == prec::Conditional) {
Daniel Jasperc01897c2013-05-31 14:56:12 +00001004 parseConditionalExpr();
1005 return;
1006 }
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001007
1008 // Parse unary operators, which all have a higher precedence than binary
1009 // operators.
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001010 if (Precedence == PrecedenceUnaryOperator) {
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001011 parseUnaryOperator();
Daniel Jasper29f123b2013-02-08 15:28:42 +00001012 return;
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001013 }
Daniel Jasper29f123b2013-02-08 15:28:42 +00001014
Manuel Klimekb3987012013-05-29 14:47:47 +00001015 FormatToken *Start = Current;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001016 FormatToken *LatestOperator = nullptr;
1017 unsigned OperatorIndex = 0;
Daniel Jasper29f123b2013-02-08 15:28:42 +00001018
Daniel Jasper237d4c12013-02-23 21:01:55 +00001019 while (Current) {
Daniel Jasper29f123b2013-02-08 15:28:42 +00001020 // Consume operators with higher precedence.
Daniel Jasperbf71ba22013-04-08 20:33:42 +00001021 parse(Precedence + 1);
Daniel Jasper29f123b2013-02-08 15:28:42 +00001022
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001023 int CurrentPrecedence = getCurrentPrecedence();
1024
1025 if (Current && Current->Type == TT_ObjCSelectorName &&
Stephen Hines651f13c2014-04-23 16:59:28 -07001026 Precedence == CurrentPrecedence) {
1027 if (LatestOperator)
1028 addFakeParenthesis(Start, prec::Level(Precedence));
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001029 Start = Current;
Stephen Hines651f13c2014-04-23 16:59:28 -07001030 }
Daniel Jasper237d4c12013-02-23 21:01:55 +00001031
Daniel Jasper29f123b2013-02-08 15:28:42 +00001032 // At the end of the line or when an operator with higher precedence is
1033 // found, insert fake parenthesis and return.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001034 if (!Current || Current->closesScope() ||
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001035 (CurrentPrecedence != -1 && CurrentPrecedence < Precedence)) {
1036 if (LatestOperator) {
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001037 LatestOperator->LastOperator = true;
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001038 if (Precedence == PrecedenceArrowAndPeriod) {
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001039 // Call expressions don't have a binary operator precedence.
1040 addFakeParenthesis(Start, prec::Unknown);
1041 } else {
1042 addFakeParenthesis(Start, prec::Level(Precedence));
1043 }
1044 }
Daniel Jasper29f123b2013-02-08 15:28:42 +00001045 return;
1046 }
1047
1048 // Consume scopes: (), [], <> and {}
Daniel Jasperac3223e2013-04-10 09:49:49 +00001049 if (Current->opensScope()) {
1050 while (Current && !Current->closesScope()) {
Daniel Jasper29f123b2013-02-08 15:28:42 +00001051 next();
1052 parse();
1053 }
1054 next();
1055 } else {
1056 // Operator found.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001057 if (CurrentPrecedence == Precedence) {
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001058 LatestOperator = Current;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001059 Current->OperatorIndex = OperatorIndex;
1060 ++OperatorIndex;
1061 }
Daniel Jasper29f123b2013-02-08 15:28:42 +00001062
1063 next();
1064 }
1065 }
1066 }
1067
1068private:
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001069 /// \brief Gets the precedence (+1) of the given token for binary operators
1070 /// and other tokens that we treat like binary operators.
1071 int getCurrentPrecedence() {
1072 if (Current) {
1073 if (Current->Type == TT_ConditionalExpr)
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001074 return prec::Conditional;
Daniel Jasper966e6d32013-11-07 19:23:49 +00001075 else if (Current->is(tok::semi) || Current->Type == TT_InlineASMColon ||
1076 Current->Type == TT_ObjCSelectorName)
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001077 return 0;
Stephen Hines651f13c2014-04-23 16:59:28 -07001078 else if (Current->Type == TT_RangeBasedForLoopColon)
1079 return prec::Comma;
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001080 else if (Current->Type == TT_BinaryOperator || Current->is(tok::comma))
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001081 return Current->getPrecedence();
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001082 else if (Current->isOneOf(tok::period, tok::arrow))
1083 return PrecedenceArrowAndPeriod;
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001084 }
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001085 return -1;
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001086 }
1087
Daniel Jasperc01897c2013-05-31 14:56:12 +00001088 void addFakeParenthesis(FormatToken *Start, prec::Level Precedence) {
1089 Start->FakeLParens.push_back(Precedence);
Daniel Jasperdb4813a2013-09-06 08:08:14 +00001090 if (Precedence > prec::Unknown)
1091 Start->StartsBinaryExpression = true;
1092 if (Current) {
Daniel Jasperc01897c2013-05-31 14:56:12 +00001093 ++Current->Previous->FakeRParens;
Daniel Jasperdb4813a2013-09-06 08:08:14 +00001094 if (Precedence > prec::Unknown)
1095 Current->Previous->EndsBinaryExpression = true;
1096 }
Daniel Jasperc01897c2013-05-31 14:56:12 +00001097 }
1098
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001099 /// \brief Parse unary operator expressions and surround them with fake
1100 /// parentheses if appropriate.
1101 void parseUnaryOperator() {
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001102 if (!Current || Current->Type != TT_UnaryOperator) {
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001103 parse(PrecedenceArrowAndPeriod);
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001104 return;
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001105 }
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001106
1107 FormatToken *Start = Current;
1108 next();
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001109 parseUnaryOperator();
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001110
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001111 // The actual precedence doesn't matter.
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001112 addFakeParenthesis(Start, prec::Unknown);
Daniel Jasper3618e6f2013-08-23 15:14:03 +00001113 }
1114
Daniel Jasperc01897c2013-05-31 14:56:12 +00001115 void parseConditionalExpr() {
1116 FormatToken *Start = Current;
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001117 parse(prec::LogicalOr);
Daniel Jasperc01897c2013-05-31 14:56:12 +00001118 if (!Current || !Current->is(tok::question))
1119 return;
1120 next();
Daniel Jasperd489f8c2013-08-27 11:09:05 +00001121 parse(prec::LogicalOr);
Daniel Jasperc01897c2013-05-31 14:56:12 +00001122 if (!Current || Current->Type != TT_ConditionalExpr)
1123 return;
1124 next();
1125 parseConditionalExpr();
1126 addFakeParenthesis(Start, prec::Conditional);
1127 }
1128
Daniel Jasper29f123b2013-02-08 15:28:42 +00001129 void next() {
Alexander Kornienkod71b15b2013-06-17 13:19:53 +00001130 if (Current)
1131 Current = Current->Next;
1132 while (Current && Current->isTrailingComment())
Manuel Klimekb3987012013-05-29 14:47:47 +00001133 Current = Current->Next;
Daniel Jasper29f123b2013-02-08 15:28:42 +00001134 }
1135
Manuel Klimekb3987012013-05-29 14:47:47 +00001136 FormatToken *Current;
Daniel Jasper29f123b2013-02-08 15:28:42 +00001137};
1138
Craig Topper14e66492013-07-01 04:03:19 +00001139} // end anonymous namespace
1140
Daniel Jasperb77d7412013-09-06 07:54:20 +00001141void
1142TokenAnnotator::setCommentLineLevels(SmallVectorImpl<AnnotatedLine *> &Lines) {
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001143 const AnnotatedLine *NextNonCommentLine = nullptr;
Daniel Jasper2a80ad62013-11-05 19:10:03 +00001144 for (SmallVectorImpl<AnnotatedLine *>::reverse_iterator I = Lines.rbegin(),
1145 E = Lines.rend();
1146 I != E; ++I) {
1147 if (NextNonCommentLine && (*I)->First->is(tok::comment) &&
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001148 (*I)->First->Next == nullptr)
Daniel Jasper2a80ad62013-11-05 19:10:03 +00001149 (*I)->Level = NextNonCommentLine->Level;
Daniel Jasperb77d7412013-09-06 07:54:20 +00001150 else
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001151 NextNonCommentLine = (*I)->First->isNot(tok::r_brace) ? (*I) : nullptr;
Daniel Jasper2a80ad62013-11-05 19:10:03 +00001152
1153 setCommentLineLevels((*I)->Children);
Daniel Jasperb77d7412013-09-06 07:54:20 +00001154 }
1155}
1156
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001157void TokenAnnotator::annotate(AnnotatedLine &Line) {
Daniel Jasperb77d7412013-09-06 07:54:20 +00001158 for (SmallVectorImpl<AnnotatedLine *>::iterator I = Line.Children.begin(),
1159 E = Line.Children.end();
Daniel Jasper567dcf92013-09-05 09:29:45 +00001160 I != E; ++I) {
1161 annotate(**I);
1162 }
Daniel Jasperd4a03db2013-08-22 15:00:41 +00001163 AnnotatingParser Parser(Style, Line, Ident_in);
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001164 Line.Type = Parser.parseLine();
1165 if (Line.Type == LT_Invalid)
1166 return;
1167
Daniel Jasper29f123b2013-02-08 15:28:42 +00001168 ExpressionParser ExprParser(Line);
1169 ExprParser.parse();
1170
Manuel Klimekb3987012013-05-29 14:47:47 +00001171 if (Line.First->Type == TT_ObjCMethodSpecifier)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001172 Line.Type = LT_ObjCMethodDecl;
Manuel Klimekb3987012013-05-29 14:47:47 +00001173 else if (Line.First->Type == TT_ObjCDecl)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001174 Line.Type = LT_ObjCDecl;
Manuel Klimekb3987012013-05-29 14:47:47 +00001175 else if (Line.First->Type == TT_ObjCProperty)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001176 Line.Type = LT_ObjCProperty;
1177
Manuel Klimekb3987012013-05-29 14:47:47 +00001178 Line.First->SpacesRequiredBefore = 1;
1179 Line.First->CanBreakBefore = Line.First->MustBreakBefore;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001180}
1181
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001182void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) {
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001183 for (SmallVectorImpl<AnnotatedLine *>::iterator I = Line.Children.begin(),
1184 E = Line.Children.end();
1185 I != E; ++I) {
1186 calculateFormattingInformation(**I);
1187 }
1188
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00001189 Line.First->TotalLength =
1190 Line.First->IsMultiline ? Style.ColumnLimit : Line.First->ColumnWidth;
Manuel Klimekb3987012013-05-29 14:47:47 +00001191 if (!Line.First->Next)
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001192 return;
Manuel Klimekb3987012013-05-29 14:47:47 +00001193 FormatToken *Current = Line.First->Next;
Daniel Jasperdbfb5f32013-11-07 17:52:51 +00001194 bool InFunctionDecl = Line.MightBeFunctionDecl;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001195 while (Current) {
Stephen Hines651f13c2014-04-23 16:59:28 -07001196 if (Current->Type == TT_LineComment) {
1197 if (Current->Previous->BlockKind == BK_BracedInit &&
1198 Current->Previous->opensScope())
1199 Current->SpacesRequiredBefore = Style.Cpp11BracedListStyle ? 0 : 1;
1200 else
1201 Current->SpacesRequiredBefore = Style.SpacesBeforeTrailingComments;
1202
1203 // If we find a trailing comment, iterate backwards to determine whether
1204 // it seems to relate to a specific parameter. If so, break before that
1205 // parameter to avoid changing the comment's meaning. E.g. don't move 'b'
1206 // to the previous line in:
1207 // SomeFunction(a,
1208 // b, // comment
1209 // c);
1210 if (!Current->HasUnescapedNewline) {
1211 for (FormatToken *Parameter = Current->Previous; Parameter;
1212 Parameter = Parameter->Previous) {
1213 if (Parameter->isOneOf(tok::comment, tok::r_brace))
1214 break;
1215 if (Parameter->Previous && Parameter->Previous->is(tok::comma)) {
1216 if (Parameter->Previous->Type != TT_CtorInitializerComma &&
1217 Parameter->HasUnescapedNewline)
1218 Parameter->MustBreakBefore = true;
1219 break;
1220 }
1221 }
1222 }
1223 } else if (Current->SpacesRequiredBefore == 0 &&
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001224 spaceRequiredBefore(Line, *Current)) {
Alexander Kornienkob18c2582013-10-11 21:43:05 +00001225 Current->SpacesRequiredBefore = 1;
Stephen Hines651f13c2014-04-23 16:59:28 -07001226 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001227
Daniel Jasperebaa1712013-09-17 09:52:48 +00001228 Current->MustBreakBefore =
1229 Current->MustBreakBefore || mustBreakBefore(Line, *Current);
1230
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001231 Current->CanBreakBefore =
1232 Current->MustBreakBefore || canBreakBefore(Line, *Current);
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001233 unsigned ChildSize = 0;
1234 if (Current->Previous->Children.size() == 1) {
1235 FormatToken &LastOfChild = *Current->Previous->Children[0]->Last;
1236 ChildSize = LastOfChild.isTrailingComment() ? Style.ColumnLimit
1237 : LastOfChild.TotalLength + 1;
1238 }
1239 if (Current->MustBreakBefore || Current->Previous->Children.size() > 1 ||
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00001240 Current->IsMultiline)
Manuel Klimekb3987012013-05-29 14:47:47 +00001241 Current->TotalLength = Current->Previous->TotalLength + Style.ColumnLimit;
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001242 else
Daniel Jasper2a409b62013-07-08 14:34:09 +00001243 Current->TotalLength = Current->Previous->TotalLength +
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001244 Current->ColumnWidth + ChildSize +
Daniel Jasper2a409b62013-07-08 14:34:09 +00001245 Current->SpacesRequiredBefore;
Daniel Jasperdbfb5f32013-11-07 17:52:51 +00001246
1247 if (Current->Type == TT_CtorInitializerColon)
1248 InFunctionDecl = false;
1249
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001250 // FIXME: Only calculate this if CanBreakBefore is true once static
1251 // initializers etc. are sorted out.
1252 // FIXME: Move magic numbers to a better place.
Daniel Jasperdbfb5f32013-11-07 17:52:51 +00001253 Current->SplitPenalty = 20 * Current->BindingStrength +
1254 splitPenalty(Line, *Current, InFunctionDecl);
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001255
Manuel Klimekb3987012013-05-29 14:47:47 +00001256 Current = Current->Next;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001257 }
Daniel Jasperbf71ba22013-04-08 20:33:42 +00001258
Manuel Klimeke573c3f2013-05-22 12:51:29 +00001259 calculateUnbreakableTailLengths(Line);
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001260 for (Current = Line.First; Current != nullptr; Current = Current->Next) {
Daniel Jasperd4a03db2013-08-22 15:00:41 +00001261 if (Current->Role)
1262 Current->Role->precomputeFormattingInfos(Current);
1263 }
1264
Daniel Jasper567dcf92013-09-05 09:29:45 +00001265 DEBUG({ printDebugInfo(Line); });
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001266}
1267
Manuel Klimeke573c3f2013-05-22 12:51:29 +00001268void TokenAnnotator::calculateUnbreakableTailLengths(AnnotatedLine &Line) {
1269 unsigned UnbreakableTailLength = 0;
Manuel Klimekb3987012013-05-29 14:47:47 +00001270 FormatToken *Current = Line.Last;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001271 while (Current) {
Manuel Klimeke573c3f2013-05-22 12:51:29 +00001272 Current->UnbreakableTailLength = UnbreakableTailLength;
1273 if (Current->CanBreakBefore ||
1274 Current->isOneOf(tok::comment, tok::string_literal)) {
1275 UnbreakableTailLength = 0;
1276 } else {
1277 UnbreakableTailLength +=
Alexander Kornienko83a7dcd2013-09-10 09:38:25 +00001278 Current->ColumnWidth + Current->SpacesRequiredBefore;
Manuel Klimeke573c3f2013-05-22 12:51:29 +00001279 }
Manuel Klimekb3987012013-05-29 14:47:47 +00001280 Current = Current->Previous;
Manuel Klimeke573c3f2013-05-22 12:51:29 +00001281 }
1282}
1283
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001284unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line,
Daniel Jasperdbfb5f32013-11-07 17:52:51 +00001285 const FormatToken &Tok,
1286 bool InFunctionDecl) {
Manuel Klimekb3987012013-05-29 14:47:47 +00001287 const FormatToken &Left = *Tok.Previous;
1288 const FormatToken &Right = Tok;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001289
Daniel Jasper5ad390d2013-05-28 11:30:49 +00001290 if (Left.is(tok::semi))
1291 return 0;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001292 if (Left.is(tok::comma) || (Right.is(tok::identifier) && Right.Next &&
1293 Right.Next->Type == TT_DictLiteral))
Daniel Jasper5ad390d2013-05-28 11:30:49 +00001294 return 1;
Stephen Hines651f13c2014-04-23 16:59:28 -07001295 if (Right.is(tok::l_square)) {
1296 if (Style.Language == FormatStyle::LK_Proto)
1297 return 1;
1298 if (Right.Type != TT_ObjCMethodExpr)
1299 return 250;
1300 }
Daniel Jasper6561f6a2013-07-09 07:43:55 +00001301 if (Right.Type == TT_StartOfName || Right.is(tok::kw_operator)) {
Manuel Klimekb3987012013-05-29 14:47:47 +00001302 if (Line.First->is(tok::kw_for) && Right.PartOfMultiVariableDeclStmt)
Daniel Jasper3c08a812013-02-24 18:54:32 +00001303 return 3;
Daniel Jasperc18cff32013-07-11 12:34:23 +00001304 if (Left.Type == TT_StartOfName)
1305 return 20;
Stephen Hines651f13c2014-04-23 16:59:28 -07001306 if (InFunctionDecl && Right.NestingLevel == 0)
Daniel Jasper3c08a812013-02-24 18:54:32 +00001307 return Style.PenaltyReturnTypeOnItsOwnLine;
Daniel Jasper92495a82013-08-19 10:16:18 +00001308 return 200;
Daniel Jasper3c08a812013-02-24 18:54:32 +00001309 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001310 if (Left.is(tok::equal) && Right.is(tok::l_brace))
1311 return 150;
Daniel Jasper198c8bf2013-07-05 07:58:34 +00001312 if (Left.Type == TT_CastRParen)
1313 return 100;
Stephen Hines651f13c2014-04-23 16:59:28 -07001314 if (Left.is(tok::coloncolon) ||
1315 (Right.is(tok::period) && Style.Language == FormatStyle::LK_Proto))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001316 return 500;
Daniel Jasper6b119d62013-04-05 17:22:09 +00001317 if (Left.isOneOf(tok::kw_class, tok::kw_struct))
1318 return 5000;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001319
Daniel Jasper6cabab42013-02-14 08:42:54 +00001320 if (Left.Type == TT_RangeBasedForLoopColon ||
1321 Left.Type == TT_InheritanceColon)
Daniel Jasper84a1a632013-02-26 13:18:08 +00001322 return 2;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001323
Daniel Jasperd3fef0f2013-08-27 14:24:43 +00001324 if (Right.isMemberAccess()) {
Stephen Hines651f13c2014-04-23 16:59:28 -07001325 if (Left.is(tok::r_paren) && Left.MatchingParen &&
Daniel Jasper2f0a0202013-09-06 08:54:24 +00001326 Left.MatchingParen->ParameterCount > 0)
Daniel Jasper518ee342013-02-26 13:59:14 +00001327 return 20; // Should be smaller than breaking at a nested comma.
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001328 return 150;
1329 }
1330
Stephen Hines651f13c2014-04-23 16:59:28 -07001331 if (Right.Type == TT_TrailingAnnotation && Right.Next &&
1332 Right.Next->isNot(tok::l_paren)) {
1333 // Generally, breaking before a trailing annotation is bad unless it is
1334 // function-like. It seems to be especially preferable to keep standard
1335 // annotations (i.e. "const", "final" and "override") on the same line.
1336 // Use a slightly higher penalty after ")" so that annotations like
1337 // "const override" are kept together.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001338 bool is_short_annotation = Right.TokenText.size() < 10;
1339 return (Left.is(tok::r_paren) ? 100 : 120) + (is_short_annotation ? 50 : 0);
Stephen Hines651f13c2014-04-23 16:59:28 -07001340 }
Daniel Jasper5ad72bb2013-05-22 08:28:26 +00001341
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001342 // In for-loops, prefer breaking at ',' and ';'.
Manuel Klimekb3987012013-05-29 14:47:47 +00001343 if (Line.First->is(tok::kw_for) && Left.is(tok::equal))
Daniel Jasper7d812812013-02-21 15:00:29 +00001344 return 4;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001345
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001346 // In Objective-C method expressions, prefer breaking before "param:" over
1347 // breaking after it.
Daniel Jasper63d7ced2013-02-05 10:07:47 +00001348 if (Right.Type == TT_ObjCSelectorName)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001349 return 0;
Daniel Jasper63d7ced2013-02-05 10:07:47 +00001350 if (Left.is(tok::colon) && Left.Type == TT_ObjCMethodExpr)
Stephen Hines651f13c2014-04-23 16:59:28 -07001351 return Line.MightBeFunctionDecl ? 50 : 500;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001352
Daniel Jasperdbfb5f32013-11-07 17:52:51 +00001353 if (Left.is(tok::l_paren) && InFunctionDecl)
Daniel Jasper1407bee2013-04-11 14:29:13 +00001354 return 100;
Stephen Hines651f13c2014-04-23 16:59:28 -07001355 if (Left.is(tok::equal) && InFunctionDecl)
1356 return 110;
Daniel Jasperac3223e2013-04-10 09:49:49 +00001357 if (Left.opensScope())
Daniel Jasper47066e42013-10-25 14:29:37 +00001358 return Left.ParameterCount > 1 ? Style.PenaltyBreakBeforeFirstCallParameter
1359 : 19;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001360
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00001361 if (Right.is(tok::lessless)) {
1362 if (Left.is(tok::string_literal)) {
Alexander Kornienko00895102013-06-05 14:09:10 +00001363 StringRef Content = Left.TokenText;
Daniel Jasper20376982013-09-29 12:02:57 +00001364 if (Content.startswith("\""))
1365 Content = Content.drop_front(1);
1366 if (Content.endswith("\""))
1367 Content = Content.drop_back(1);
1368 Content = Content.trim();
Daniel Jasperbfa1edd2013-03-14 14:00:17 +00001369 if (Content.size() > 1 &&
1370 (Content.back() == ':' || Content.back() == '='))
Daniel Jasper9637dda2013-07-15 14:33:14 +00001371 return 25;
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00001372 }
Daniel Jasper0c368782013-07-15 15:04:42 +00001373 return 1; // Breaking at a << is really cheap.
Daniel Jasper4e8a7b42013-02-06 21:04:05 +00001374 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001375 if (Left.Type == TT_ConditionalExpr)
Daniel Jasper518ee342013-02-26 13:59:14 +00001376 return prec::Conditional;
Manuel Klimekb3987012013-05-29 14:47:47 +00001377 prec::Level Level = Left.getPrecedence();
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001378
1379 if (Level != prec::Unknown)
1380 return Level;
Daniel Jasper24849712013-03-01 16:48:32 +00001381
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001382 return 3;
1383}
1384
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001385bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
Manuel Klimekb3987012013-05-29 14:47:47 +00001386 const FormatToken &Left,
1387 const FormatToken &Right) {
Stephen Hines651f13c2014-04-23 16:59:28 -07001388 if (Style.Language == FormatStyle::LK_Proto) {
1389 if (Right.is(tok::l_paren) &&
1390 (Left.TokenText == "returns" || Left.TokenText == "option"))
1391 return true;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001392 } else if (Style.Language == FormatStyle::LK_JavaScript) {
1393 if (Left.TokenText == "var")
1394 return true;
Stephen Hines651f13c2014-04-23 16:59:28 -07001395 }
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001396 if (Left.is(tok::kw_return) && Right.isNot(tok::semi))
1397 return true;
Stephen Hines651f13c2014-04-23 16:59:28 -07001398 if (Style.ObjCSpaceAfterProperty && Line.Type == LT_ObjCProperty &&
1399 Left.Tok.getObjCKeywordID() == tok::objc_property)
1400 return true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001401 if (Right.is(tok::hashhash))
1402 return Left.is(tok::hash);
Alexander Kornienkoe74de282013-03-13 14:41:29 +00001403 if (Left.isOneOf(tok::hashhash, tok::hash))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001404 return Right.is(tok::hash);
Daniel Jasper7df56bf2013-08-20 12:36:34 +00001405 if (Left.is(tok::l_paren) && Right.is(tok::r_paren))
1406 return Style.SpaceInEmptyParentheses;
1407 if (Left.is(tok::l_paren) || Right.is(tok::r_paren))
Daniel Jasper34f3d052013-08-21 08:39:01 +00001408 return (Right.Type == TT_CastRParen ||
1409 (Left.MatchingParen && Left.MatchingParen->Type == TT_CastRParen))
Daniel Jasper7df56bf2013-08-20 12:36:34 +00001410 ? Style.SpacesInCStyleCastParentheses
1411 : Style.SpacesInParentheses;
Daniel Jasperd8ee5c12013-10-29 14:52:02 +00001412 if (Style.SpacesInAngles &&
1413 ((Left.Type == TT_TemplateOpener) != (Right.Type == TT_TemplateCloser)))
1414 return true;
Daniel Jasper7df56bf2013-08-20 12:36:34 +00001415 if (Right.isOneOf(tok::semi, tok::comma))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001416 return false;
1417 if (Right.is(tok::less) &&
1418 (Left.is(tok::kw_template) ||
1419 (Line.Type == LT_ObjCDecl && Style.ObjCSpaceBeforeProtocolList)))
1420 return true;
1421 if (Left.is(tok::arrow) || Right.is(tok::arrow))
1422 return false;
Alexander Kornienkoe74de282013-03-13 14:41:29 +00001423 if (Left.isOneOf(tok::exclaim, tok::tilde))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001424 return false;
1425 if (Left.is(tok::at) &&
Alexander Kornienkoe74de282013-03-13 14:41:29 +00001426 Right.isOneOf(tok::identifier, tok::string_literal, tok::char_constant,
1427 tok::numeric_constant, tok::l_paren, tok::l_brace,
1428 tok::kw_true, tok::kw_false))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001429 return false;
1430 if (Left.is(tok::coloncolon))
1431 return false;
Stephen Hines651f13c2014-04-23 16:59:28 -07001432 if (Right.is(tok::coloncolon) && Left.isNot(tok::l_brace))
Daniel Jasper78a4e612013-10-12 05:16:06 +00001433 return (Left.is(tok::less) && Style.Standard == FormatStyle::LS_Cpp03) ||
1434 !Left.isOneOf(tok::identifier, tok::greater, tok::l_paren,
1435 tok::r_paren, tok::less);
Alexander Kornienkoe74de282013-03-13 14:41:29 +00001436 if (Left.is(tok::less) || Right.isOneOf(tok::greater, tok::less))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001437 return false;
Daniel Jasperc47d7f12013-07-01 09:47:25 +00001438 if (Right.is(tok::ellipsis))
Daniel Jasperb3c887d2013-10-20 16:56:16 +00001439 return Left.Tok.isLiteral();
Manuel Klimek31e44f72013-09-04 08:20:47 +00001440 if (Left.is(tok::l_square) && Right.is(tok::amp))
1441 return false;
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00001442 if (Right.Type == TT_PointerOrReference)
Manuel Klimekb3987012013-05-29 14:47:47 +00001443 return Left.Tok.isLiteral() ||
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00001444 ((Left.Type != TT_PointerOrReference) && Left.isNot(tok::l_paren) &&
1445 !Style.PointerBindsToType);
Daniel Jasper3ff4a2f2013-05-28 15:27:10 +00001446 if (Right.Type == TT_FunctionTypeLParen && Left.isNot(tok::l_paren) &&
Daniel Jasper395228f2013-05-08 14:58:20 +00001447 (Left.Type != TT_PointerOrReference || Style.PointerBindsToType))
1448 return true;
Alexander Kornienko3fd9ccd2013-03-12 16:28:18 +00001449 if (Left.Type == TT_PointerOrReference)
Daniel Jasper3a1847e2013-07-01 09:34:09 +00001450 return Right.Tok.isLiteral() || Right.Type == TT_BlockComment ||
Daniel Jasper9322aae2013-03-20 09:53:18 +00001451 ((Right.Type != TT_PointerOrReference) &&
Daniel Jasper81d2d382013-04-01 17:13:26 +00001452 Right.isNot(tok::l_paren) && Style.PointerBindsToType &&
Manuel Klimekb3987012013-05-29 14:47:47 +00001453 Left.Previous &&
1454 !Left.Previous->isOneOf(tok::l_paren, tok::coloncolon));
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001455 if (Right.is(tok::star) && Left.is(tok::l_paren))
1456 return false;
Nico Weber051860e2013-02-10 02:08:05 +00001457 if (Left.is(tok::l_square))
Daniel Jaspera07aa662013-10-22 15:30:28 +00001458 return Left.Type == TT_ArrayInitializerLSquare &&
Stephen Hines651f13c2014-04-23 16:59:28 -07001459 Style.SpacesInContainerLiterals && Right.isNot(tok::r_square);
Nico Weber051860e2013-02-10 02:08:05 +00001460 if (Right.is(tok::r_square))
Stephen Hines651f13c2014-04-23 16:59:28 -07001461 return Right.MatchingParen && Style.SpacesInContainerLiterals &&
Daniel Jaspera07aa662013-10-22 15:30:28 +00001462 Right.MatchingParen->Type == TT_ArrayInitializerLSquare;
Daniel Jasperec172262013-08-30 10:36:58 +00001463 if (Right.is(tok::l_square) && Right.Type != TT_ObjCMethodExpr &&
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001464 Right.Type != TT_LambdaLSquare && Left.isNot(tok::numeric_constant) &&
1465 Left.Type != TT_DictLiteral)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001466 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001467 if (Left.is(tok::colon))
1468 return Left.Type != TT_ObjCMethodExpr;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001469 if (Left.Type == TT_BlockComment)
1470 return !Left.TokenText.endswith("=*/");
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001471 if (Right.is(tok::l_paren)) {
Stephen Hines651f13c2014-04-23 16:59:28 -07001472 if (Left.is(tok::r_paren) && Left.Type == TT_AttributeParen)
Daniel Jaspere0fa4c52013-07-17 20:25:02 +00001473 return true;
Alexander Kornienkoe74de282013-03-13 14:41:29 +00001474 return Line.Type == LT_ObjCDecl ||
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001475 Left.isOneOf(tok::kw_new, tok::kw_delete, tok::semi) ||
Stephen Hines651f13c2014-04-23 16:59:28 -07001476 (Style.SpaceBeforeParens != FormatStyle::SBPO_Never &&
1477 (Left.isOneOf(tok::kw_if, tok::kw_for, tok::kw_while,
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001478 tok::kw_switch, tok::kw_catch, tok::kw_case) ||
Stephen Hines651f13c2014-04-23 16:59:28 -07001479 Left.IsForEachMacro)) ||
1480 (Style.SpaceBeforeParens == FormatStyle::SBPO_Always &&
1481 Left.isOneOf(tok::identifier, tok::kw___attribute) &&
1482 Line.Type != LT_PreprocessorDirective);
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001483 }
Manuel Klimekb3987012013-05-29 14:47:47 +00001484 if (Left.is(tok::at) && Right.Tok.getObjCKeywordID() != tok::objc_not_keyword)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001485 return false;
1486 if (Left.is(tok::l_brace) && Right.is(tok::r_brace))
Daniel Jasper567dcf92013-09-05 09:29:45 +00001487 return !Left.Children.empty(); // No spaces in "{}".
Stephen Hines651f13c2014-04-23 16:59:28 -07001488 if ((Left.is(tok::l_brace) && Left.BlockKind != BK_Block) ||
1489 (Right.is(tok::r_brace) && Right.MatchingParen &&
1490 Right.MatchingParen->BlockKind != BK_Block))
Daniel Jasperb5dc3f42013-07-16 18:22:10 +00001491 return !Style.Cpp11BracedListStyle;
Daniel Jasper1bee0732013-05-23 18:05:18 +00001492 if (Right.Type == TT_UnaryOperator)
1493 return !Left.isOneOf(tok::l_paren, tok::l_square, tok::at) &&
1494 (Left.isNot(tok::colon) || Left.Type != TT_ObjCMethodExpr);
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001495 if ((Left.isOneOf(tok::identifier, tok::greater, tok::r_square) ||
1496 Left.isSimpleTypeSpecifier()) &&
Manuel Klimek31e44f72013-09-04 08:20:47 +00001497 Right.is(tok::l_brace) && Right.getNextNonComment() &&
1498 Right.BlockKind != BK_Block)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001499 return false;
Daniel Jasper5ad390d2013-05-28 11:30:49 +00001500 if (Left.is(tok::period) || Right.is(tok::period))
1501 return false;
Alexander Kornienkodaa07e92013-09-10 13:41:43 +00001502 if (Right.is(tok::hash) && Left.is(tok::identifier) && Left.TokenText == "L")
1503 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001504 return true;
1505}
1506
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001507bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line,
Manuel Klimekb3987012013-05-29 14:47:47 +00001508 const FormatToken &Tok) {
1509 if (Tok.Tok.getIdentifierInfo() && Tok.Previous->Tok.getIdentifierInfo())
Daniel Jasper2b4c9242013-02-11 08:01:18 +00001510 return true; // Never ever merge two identifiers.
Daniel Jasper1d82b1a2013-10-11 19:45:02 +00001511 if (Tok.Previous->Type == TT_ImplicitStringLiteral)
1512 return Tok.WhitespaceRange.getBegin() != Tok.WhitespaceRange.getEnd();
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001513 if (Line.Type == LT_ObjCMethodDecl) {
Manuel Klimekb3987012013-05-29 14:47:47 +00001514 if (Tok.Previous->Type == TT_ObjCMethodSpecifier)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001515 return true;
Manuel Klimekb3987012013-05-29 14:47:47 +00001516 if (Tok.Previous->is(tok::r_paren) && Tok.is(tok::identifier))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001517 // Don't space between ')' and <id>
1518 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001519 }
1520 if (Line.Type == LT_ObjCProperty &&
Manuel Klimekb3987012013-05-29 14:47:47 +00001521 (Tok.is(tok::equal) || Tok.Previous->is(tok::equal)))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001522 return false;
1523
Daniel Jasper2ca37412013-07-09 14:36:48 +00001524 if (Tok.Type == TT_TrailingReturnArrow ||
1525 Tok.Previous->Type == TT_TrailingReturnArrow)
1526 return true;
Manuel Klimekb3987012013-05-29 14:47:47 +00001527 if (Tok.Previous->is(tok::comma))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001528 return true;
Daniel Jasper9c3c7b32013-02-28 13:40:17 +00001529 if (Tok.is(tok::comma))
1530 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001531 if (Tok.Type == TT_CtorInitializerColon || Tok.Type == TT_ObjCBlockLParen)
1532 return true;
Manuel Klimekb3987012013-05-29 14:47:47 +00001533 if (Tok.Previous->Tok.is(tok::kw_operator))
Daniel Jasper52af9442013-10-29 12:24:23 +00001534 return Tok.is(tok::coloncolon);
Daniel Jasper2b4c9242013-02-11 08:01:18 +00001535 if (Tok.Type == TT_OverloadedOperatorLParen)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001536 return false;
1537 if (Tok.is(tok::colon))
Manuel Klimekb3987012013-05-29 14:47:47 +00001538 return !Line.First->isOneOf(tok::kw_case, tok::kw_default) &&
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001539 Tok.getNextNonComment() && Tok.Type != TT_ObjCMethodExpr &&
Stephen Hines651f13c2014-04-23 16:59:28 -07001540 !Tok.Previous->is(tok::question) &&
1541 (Tok.Type != TT_DictLiteral || Style.SpacesInContainerLiterals);
Manuel Klimekb3987012013-05-29 14:47:47 +00001542 if (Tok.Previous->Type == TT_UnaryOperator ||
1543 Tok.Previous->Type == TT_CastRParen)
Stephen Hines651f13c2014-04-23 16:59:28 -07001544 return Tok.Type == TT_BinaryOperator;
Manuel Klimekb3987012013-05-29 14:47:47 +00001545 if (Tok.Previous->is(tok::greater) && Tok.is(tok::greater)) {
Daniel Jasper29f123b2013-02-08 15:28:42 +00001546 return Tok.Type == TT_TemplateCloser &&
Manuel Klimekb3987012013-05-29 14:47:47 +00001547 Tok.Previous->Type == TT_TemplateCloser &&
Daniel Jasperd8ee5c12013-10-29 14:52:02 +00001548 (Style.Standard != FormatStyle::LS_Cpp11 || Style.SpacesInAngles);
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001549 }
Alexander Kornienko54a38bd2013-03-20 16:41:56 +00001550 if (Tok.isOneOf(tok::arrowstar, tok::periodstar) ||
Manuel Klimekb3987012013-05-29 14:47:47 +00001551 Tok.Previous->isOneOf(tok::arrowstar, tok::periodstar))
Daniel Jasper9c3c7b32013-02-28 13:40:17 +00001552 return false;
Daniel Jasper9b4de852013-09-25 15:15:02 +00001553 if (!Style.SpaceBeforeAssignmentOperators &&
1554 Tok.getPrecedence() == prec::Assignment)
1555 return false;
Daniel Jasper1dc6f742013-08-07 16:29:23 +00001556 if ((Tok.Type == TT_BinaryOperator && !Tok.Previous->is(tok::l_paren)) ||
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001557 Tok.Previous->Type == TT_BinaryOperator ||
1558 Tok.Previous->Type == TT_ConditionalExpr)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001559 return true;
Manuel Klimekb3987012013-05-29 14:47:47 +00001560 if (Tok.Previous->Type == TT_TemplateCloser && Tok.is(tok::l_paren))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001561 return false;
Daniel Jaspera4dd9822013-08-28 08:24:04 +00001562 if (Tok.is(tok::less) && Tok.Previous->isNot(tok::l_paren) &&
1563 Line.First->is(tok::hash))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001564 return true;
1565 if (Tok.Type == TT_TrailingUnaryOperator)
1566 return false;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001567 if (Tok.Previous->Type == TT_RegexLiteral)
1568 return false;
Manuel Klimekb3987012013-05-29 14:47:47 +00001569 return spaceRequiredBetween(Line, *Tok.Previous, Tok);
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001570}
1571
Daniel Jasperebaa1712013-09-17 09:52:48 +00001572bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line,
1573 const FormatToken &Right) {
Stephen Hines651f13c2014-04-23 16:59:28 -07001574 const FormatToken &Left = *Right.Previous;
Daniel Jasperebaa1712013-09-17 09:52:48 +00001575 if (Right.is(tok::comment)) {
Stephen Hines651f13c2014-04-23 16:59:28 -07001576 return Right.Previous->BlockKind != BK_BracedInit &&
1577 Right.Previous->Type != TT_CtorInitializerColon &&
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001578 (Right.NewlinesBefore > 0 && Right.HasUnescapedNewline);
Daniel Jasperebaa1712013-09-17 09:52:48 +00001579 } else if (Right.Previous->isTrailingComment() ||
Stephen Hines651f13c2014-04-23 16:59:28 -07001580 (Right.isStringLiteral() && Right.Previous->isStringLiteral())) {
Daniel Jasperebaa1712013-09-17 09:52:48 +00001581 return true;
1582 } else if (Right.Previous->IsUnterminatedLiteral) {
1583 return true;
1584 } else if (Right.is(tok::lessless) && Right.Next &&
1585 Right.Previous->is(tok::string_literal) &&
1586 Right.Next->is(tok::string_literal)) {
1587 return true;
1588 } else if (Right.Previous->ClosesTemplateDeclaration &&
1589 Right.Previous->MatchingParen &&
Stephen Hines651f13c2014-04-23 16:59:28 -07001590 Right.Previous->MatchingParen->NestingLevel == 0 &&
Daniel Jasperebaa1712013-09-17 09:52:48 +00001591 Style.AlwaysBreakTemplateDeclarations) {
Daniel Jasperebaa1712013-09-17 09:52:48 +00001592 return true;
Stephen Hines651f13c2014-04-23 16:59:28 -07001593 } else if ((Right.Type == TT_CtorInitializerComma ||
1594 Right.Type == TT_CtorInitializerColon) &&
Daniel Jasper19ccb122013-10-08 05:11:18 +00001595 Style.BreakConstructorInitializersBeforeComma &&
1596 !Style.ConstructorInitializerAllOnOneLineOrOnePerLine) {
Daniel Jasperebaa1712013-09-17 09:52:48 +00001597 return true;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001598 } else if (Right.is(tok::l_brace) && Right.BlockKind == BK_Block &&
1599 Right.Type != TT_ObjCBlockLBrace && Right.Type != TT_DictLiteral) {
Stephen Hines651f13c2014-04-23 16:59:28 -07001600 return Style.BreakBeforeBraces == FormatStyle::BS_Allman ||
1601 Style.BreakBeforeBraces == FormatStyle::BS_GNU;
1602 } else if (Right.is(tok::string_literal) &&
1603 Right.TokenText.startswith("R\"")) {
1604 // Raw string literals are special wrt. line breaks. The author has made a
1605 // deliberate choice and might have aligned the contents of the string
1606 // literal accordingly. Thus, we try keep existing line breaks.
1607 return Right.NewlinesBefore > 0;
1608 } else if (Right.Previous->is(tok::l_brace) && Right.NestingLevel == 1 &&
1609 Style.Language == FormatStyle::LK_Proto) {
1610 // Don't enums onto single lines in protocol buffers.
1611 return true;
Daniel Jasperebaa1712013-09-17 09:52:48 +00001612 }
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001613
1614 // If the last token before a '}' is a comma or a comment, the intention is to
1615 // insert a line break after it in order to make shuffling around entries
1616 // easier.
1617 const FormatToken *BeforeClosingBrace = nullptr;
1618 if (Left.is(tok::l_brace) && Left.MatchingParen)
1619 BeforeClosingBrace = Left.MatchingParen->Previous;
1620 else if (Right.is(tok::r_brace))
1621 BeforeClosingBrace = Right.Previous;
1622 if (BeforeClosingBrace &&
1623 BeforeClosingBrace->isOneOf(tok::comma, tok::comment))
1624 return true;
1625
1626 if (Style.Language == FormatStyle::LK_JavaScript) {
1627 // FIXME: This might apply to other languages and token kinds.
1628 if (Right.is(tok::char_constant) && Left.is(tok::plus) && Left.Previous &&
1629 Left.Previous->is(tok::char_constant))
1630 return true;
1631 }
1632
Daniel Jasperebaa1712013-09-17 09:52:48 +00001633 return false;
1634}
1635
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001636bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line,
Manuel Klimekb3987012013-05-29 14:47:47 +00001637 const FormatToken &Right) {
1638 const FormatToken &Left = *Right.Previous;
Stephen Hines651f13c2014-04-23 16:59:28 -07001639 if (Left.is(tok::at))
1640 return false;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001641 if (Left.Tok.getObjCKeywordID() == tok::objc_interface)
1642 return false;
Daniel Jasper6561f6a2013-07-09 07:43:55 +00001643 if (Right.Type == TT_StartOfName || Right.is(tok::kw_operator))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001644 return true;
Daniel Jasper1a896a52013-11-08 00:57:11 +00001645 if (Right.isTrailingComment())
1646 // We rely on MustBreakBefore being set correctly here as we should not
1647 // change the "binding" behavior of a comment.
Stephen Hines651f13c2014-04-23 16:59:28 -07001648 // The first comment in a braced lists is always interpreted as belonging to
1649 // the first list element. Otherwise, it should be placed outside of the
1650 // list.
1651 return Left.BlockKind == BK_BracedInit;
Daniel Jasper1a896a52013-11-08 00:57:11 +00001652 if (Left.is(tok::question) && Right.is(tok::colon))
1653 return false;
1654 if (Right.Type == TT_ConditionalExpr || Right.is(tok::question))
1655 return Style.BreakBeforeTernaryOperators;
1656 if (Left.Type == TT_ConditionalExpr || Left.is(tok::question))
1657 return !Style.BreakBeforeTernaryOperators;
Nico Weberf2ff8122013-05-26 05:39:26 +00001658 if (Right.is(tok::colon) &&
Daniel Jasper3c6aea72013-10-24 10:31:50 +00001659 (Right.Type == TT_DictLiteral || Right.Type == TT_ObjCMethodExpr))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001660 return false;
Stephen Hines651f13c2014-04-23 16:59:28 -07001661 if (Right.Type == TT_InheritanceColon)
1662 return true;
Nico Weberf2ff8122013-05-26 05:39:26 +00001663 if (Left.is(tok::colon) &&
Daniel Jasper3c6aea72013-10-24 10:31:50 +00001664 (Left.Type == TT_DictLiteral || Left.Type == TT_ObjCMethodExpr))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001665 return true;
Daniel Jasper63d7ced2013-02-05 10:07:47 +00001666 if (Right.Type == TT_ObjCSelectorName)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001667 return true;
Daniel Jasperaa9e7b12013-08-01 13:46:58 +00001668 if (Left.is(tok::r_paren) && Line.Type == LT_ObjCProperty)
1669 return true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001670 if (Left.ClosesTemplateDeclaration)
1671 return true;
Daniel Jasper6cabab42013-02-14 08:42:54 +00001672 if (Right.Type == TT_RangeBasedForLoopColon ||
Daniel Jasperc476ea92013-08-28 07:27:35 +00001673 Right.Type == TT_OverloadedOperatorLParen ||
1674 Right.Type == TT_OverloadedOperator)
Daniel Jasper6cabab42013-02-14 08:42:54 +00001675 return false;
Daniel Jasperc194c952013-05-06 06:45:09 +00001676 if (Left.Type == TT_RangeBasedForLoopColon)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001677 return true;
Daniel Jasper7d812812013-02-21 15:00:29 +00001678 if (Right.Type == TT_RangeBasedForLoopColon)
1679 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001680 if (Left.Type == TT_PointerOrReference || Left.Type == TT_TemplateCloser ||
Daniel Jasper1a896a52013-11-08 00:57:11 +00001681 Left.Type == TT_UnaryOperator || Left.is(tok::kw_operator))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001682 return false;
1683 if (Left.is(tok::equal) && Line.Type == LT_VirtualFunctionDecl)
1684 return false;
Stephen Hines651f13c2014-04-23 16:59:28 -07001685 if (Left.is(tok::l_paren) && Left.Type == TT_AttributeParen)
1686 return false;
1687 if (Left.is(tok::l_paren) && Left.Previous &&
1688 (Left.Previous->Type == TT_BinaryOperator ||
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001689 Left.Previous->Type == TT_CastRParen || Left.Previous->is(tok::kw_if)))
Stephen Hines651f13c2014-04-23 16:59:28 -07001690 return false;
Daniel Jasper84379572013-10-30 13:54:53 +00001691 if (Right.Type == TT_ImplicitStringLiteral)
1692 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001693
Daniel Jasper567dcf92013-09-05 09:29:45 +00001694 if (Right.is(tok::r_paren) || Right.Type == TT_TemplateCloser)
1695 return false;
1696
Daniel Jasper5ad72bb2013-05-22 08:28:26 +00001697 // We only break before r_brace if there was a corresponding break before
1698 // the l_brace, which is tracked by BreakBeforeClosingBrace.
Daniel Jasper567dcf92013-09-05 09:29:45 +00001699 if (Right.is(tok::r_brace))
1700 return Right.MatchingParen && Right.MatchingParen->BlockKind == BK_Block;
Daniel Jasper5ad72bb2013-05-22 08:28:26 +00001701
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001702 // Allow breaking after a trailing annotation, e.g. after a method
1703 // declaration.
1704 if (Left.Type == TT_TrailingAnnotation)
1705 return !Right.isOneOf(tok::l_brace, tok::semi, tok::equal, tok::l_paren,
1706 tok::less, tok::coloncolon);
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001707
Daniel Jasper8ef19a22013-03-14 09:50:46 +00001708 if (Right.is(tok::kw___attribute))
1709 return true;
1710
Daniel Jasper3a204412013-02-23 07:46:38 +00001711 if (Left.is(tok::identifier) && Right.is(tok::string_literal))
1712 return true;
Daniel Jaspere8b10d32013-07-26 16:56:36 +00001713
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001714 if (Right.is(tok::identifier) && Right.Next &&
1715 Right.Next->Type == TT_DictLiteral)
1716 return true;
1717
Daniel Jaspere8b10d32013-07-26 16:56:36 +00001718 if (Left.Type == TT_CtorInitializerComma &&
1719 Style.BreakConstructorInitializersBeforeComma)
1720 return false;
Daniel Jasper19ccb122013-10-08 05:11:18 +00001721 if (Right.Type == TT_CtorInitializerComma &&
1722 Style.BreakConstructorInitializersBeforeComma)
1723 return true;
Daniel Jasper26356cc2013-09-17 08:15:46 +00001724 if (Left.is(tok::greater) && Right.is(tok::greater) &&
1725 Left.Type != TT_TemplateCloser)
1726 return false;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001727 if (Right.Type == TT_BinaryOperator && Style.BreakBeforeBinaryOperators)
1728 return true;
Daniel Jaspera07aa662013-10-22 15:30:28 +00001729 if (Left.Type == TT_ArrayInitializerLSquare)
1730 return true;
Daniel Jaspere8b10d32013-07-26 16:56:36 +00001731 return (Left.isBinaryOperator() && Left.isNot(tok::lessless) &&
1732 !Style.BreakBeforeBinaryOperators) ||
Daniel Jasper6b119d62013-04-05 17:22:09 +00001733 Left.isOneOf(tok::comma, tok::coloncolon, tok::semi, tok::l_brace,
1734 tok::kw_class, tok::kw_struct) ||
Daniel Jaspera07aa662013-10-22 15:30:28 +00001735 Right.isOneOf(tok::lessless, tok::arrow, tok::period, tok::colon,
1736 tok::l_square, tok::at) ||
Daniel Jasper198c8bf2013-07-05 07:58:34 +00001737 (Left.is(tok::r_paren) &&
Stephen Hines651f13c2014-04-23 16:59:28 -07001738 Right.isOneOf(tok::identifier, tok::kw_const)) ||
Daniel Jaspera07aa662013-10-22 15:30:28 +00001739 (Left.is(tok::l_paren) && !Right.is(tok::r_paren));
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001740}
1741
Daniel Jasperbf71ba22013-04-08 20:33:42 +00001742void TokenAnnotator::printDebugInfo(const AnnotatedLine &Line) {
1743 llvm::errs() << "AnnotatedTokens:\n";
Manuel Klimekb3987012013-05-29 14:47:47 +00001744 const FormatToken *Tok = Line.First;
Daniel Jasperbf71ba22013-04-08 20:33:42 +00001745 while (Tok) {
Manuel Klimekb3987012013-05-29 14:47:47 +00001746 llvm::errs() << " M=" << Tok->MustBreakBefore
Daniel Jasperc7bd68f2013-07-10 14:02:49 +00001747 << " C=" << Tok->CanBreakBefore << " T=" << Tok->Type
1748 << " S=" << Tok->SpacesRequiredBefore
1749 << " P=" << Tok->SplitPenalty << " Name=" << Tok->Tok.getName()
Manuel Klimekae76f7f2013-10-11 21:25:45 +00001750 << " L=" << Tok->TotalLength << " PPK=" << Tok->PackingKind
1751 << " FakeLParens=";
Daniel Jasperbf71ba22013-04-08 20:33:42 +00001752 for (unsigned i = 0, e = Tok->FakeLParens.size(); i != e; ++i)
1753 llvm::errs() << Tok->FakeLParens[i] << "/";
1754 llvm::errs() << " FakeRParens=" << Tok->FakeRParens << "\n";
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001755 if (!Tok->Next)
Manuel Klimekae76f7f2013-10-11 21:25:45 +00001756 assert(Tok == Line.Last);
Manuel Klimekb3987012013-05-29 14:47:47 +00001757 Tok = Tok->Next;
Daniel Jasperbf71ba22013-04-08 20:33:42 +00001758 }
1759 llvm::errs() << "----\n";
1760}
1761
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001762} // namespace format
1763} // namespace clang