blob: 7733b8a6e951a7c1f4b754b954db01e96b403a52 [file] [log] [blame]
Daniel Jasper7a6d09b2013-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 Jasper6bee6822013-04-08 20:33:42 +000018#include "llvm/Support/Debug.h"
Daniel Jasper7a6d09b2013-01-29 21:01:14 +000019
Chandler Carruth57f5fbe2014-04-21 22:55:36 +000020#define DEBUG_TYPE "format-token-annotator"
21
Daniel Jasper7a6d09b2013-01-29 21:01:14 +000022namespace clang {
23namespace format {
24
Craig Topper318ed7c2013-07-01 04:03:19 +000025namespace {
26
Daniel Jasper7a6d09b2013-01-29 21:01:14 +000027/// \brief A parser that gathers additional information about tokens.
28///
Alexander Kornienkoa5151272013-03-12 16:28:18 +000029/// The \c TokenAnnotator tries to match parenthesis and square brakets and
Daniel Jasper7a6d09b2013-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 Jasper8de9ed02013-08-22 15:00:41 +000034 AnnotatingParser(const FormatStyle &Style, AnnotatedLine &Line,
Daniel Jasperd0ec0d62014-11-04 12:41:02 +000035 const AdditionalKeywords &Keywords)
Daniel Jasper616de8642014-11-23 16:46:28 +000036 : Style(Style), Line(Line), CurrentToken(Line.First), AutoFound(false),
37 Keywords(Keywords) {
Nico Weber9096fc02013-06-26 00:30:14 +000038 Contexts.push_back(Context(tok::unknown, 1, /*IsExpression=*/false));
Manuel Klimek819788d2014-03-18 11:22:45 +000039 resetTokenMetadata(CurrentToken);
Daniel Jasper7a6d09b2013-01-29 21:01:14 +000040 }
41
Nico Weber44449172013-02-12 16:17:07 +000042private:
Daniel Jasper7a6d09b2013-01-29 21:01:14 +000043 bool parseAngle() {
Craig Topper2145bc02014-05-09 08:15:10 +000044 if (!CurrentToken)
Daniel Jasper7a6d09b2013-01-29 21:01:14 +000045 return false;
Daniel Jasper40aacf42013-03-14 13:45:21 +000046 ScopedContextCreator ContextCreator(*this, tok::less, 10);
Manuel Klimek6e6310e2013-05-29 14:47:47 +000047 FormatToken *Left = CurrentToken->Previous;
Daniel Jasperc697ad22013-02-06 10:05:46 +000048 Contexts.back().IsExpression = false;
Manuel Klimekf81e5c02014-03-27 11:17:36 +000049 // If there's a template keyword before the opening angle bracket, this is a
50 // template parameter, not an argument.
51 Contexts.back().InTemplateArgument =
Craig Topper2145bc02014-05-09 08:15:10 +000052 Left->Previous && Left->Previous->Tok.isNot(tok::kw_template);
Manuel Klimekf81e5c02014-03-27 11:17:36 +000053
Daniel Jasper16b107e2014-10-21 09:57:09 +000054 if (Style.Language == FormatStyle::LK_Java &&
55 CurrentToken->is(tok::question))
56 next();
57
Craig Topper2145bc02014-05-09 08:15:10 +000058 while (CurrentToken) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +000059 if (CurrentToken->is(tok::greater)) {
60 Left->MatchingParen = CurrentToken;
61 CurrentToken->MatchingParen = Left;
62 CurrentToken->Type = TT_TemplateCloser;
63 next();
64 return true;
65 }
Daniel Jasper7bd618f2014-11-02 21:52:57 +000066 if (CurrentToken->is(tok::question) &&
Daniel Jasper61d81972014-11-14 08:22:46 +000067 Style.Language == FormatStyle::LK_Java) {
68 next();
69 continue;
70 }
71 if (CurrentToken->isOneOf(tok::r_paren, tok::r_square, tok::r_brace,
72 tok::colon, tok::question))
Daniel Jasper6f05e592013-05-15 13:46:48 +000073 return false;
Daniel Jasperd5893912013-06-01 18:56:00 +000074 // If a && or || is found and interpreted as a binary operator, this set
Daniel Jasper1027c6e2013-06-03 16:16:41 +000075 // of angles is likely part of something like "a < b && c > d". If the
Daniel Jasperd5893912013-06-01 18:56:00 +000076 // angles are inside an expression, the ||/&& might also be a binary
77 // operator that was misinterpreted because we are parsing template
78 // parameters.
79 // FIXME: This is getting out of hand, write a decent parser.
Manuel Klimek6e6310e2013-05-29 14:47:47 +000080 if (CurrentToken->Previous->isOneOf(tok::pipepipe, tok::ampamp) &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +000081 CurrentToken->Previous->is(TT_BinaryOperator) &&
Daniel Jasper6ba16382014-07-28 13:19:58 +000082 Contexts[Contexts.size() - 2].IsExpression &&
Manuel Klimek6e6310e2013-05-29 14:47:47 +000083 Line.First->isNot(tok::kw_template))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +000084 return false;
Daniel Jaspere11095a2013-02-14 15:01:34 +000085 updateParameterCount(Left, CurrentToken);
Daniel Jasper7a6d09b2013-01-29 21:01:14 +000086 if (!consumeToken())
87 return false;
88 }
89 return false;
90 }
91
92 bool parseParens(bool LookForDecls = false) {
Craig Topper2145bc02014-05-09 08:15:10 +000093 if (!CurrentToken)
Daniel Jasper7a6d09b2013-01-29 21:01:14 +000094 return false;
Daniel Jasper40aacf42013-03-14 13:45:21 +000095 ScopedContextCreator ContextCreator(*this, tok::l_paren, 1);
Daniel Jasperc697ad22013-02-06 10:05:46 +000096
97 // FIXME: This is a bit of a hack. Do better.
98 Contexts.back().ColonIsForRangeExpr =
99 Contexts.size() == 2 && Contexts[0].ColonIsForRangeExpr;
100
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000101 bool StartsObjCMethodExpr = false;
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000102 FormatToken *Left = CurrentToken->Previous;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000103 if (CurrentToken->is(tok::caret)) {
Daniel Jasperb88b25f2013-12-23 07:29:06 +0000104 // (^ can start a block type.
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000105 Left->Type = TT_ObjCBlockLParen;
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000106 } else if (FormatToken *MaybeSel = Left->Previous) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000107 // @selector( starts a selector.
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000108 if (MaybeSel->isObjCAtKeyword(tok::objc_selector) && MaybeSel->Previous &&
109 MaybeSel->Previous->is(tok::at)) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000110 StartsObjCMethodExpr = true;
111 }
112 }
113
Daniel Jaspera65e8872014-03-25 10:52:45 +0000114 if (Left->Previous &&
115 (Left->Previous->isOneOf(tok::kw_static_assert, tok::kw_if,
116 tok::kw_while, tok::l_paren, tok::comma) ||
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000117 Left->Previous->is(TT_BinaryOperator))) {
Daniel Jasperd46e07e2013-10-20 18:15:30 +0000118 // static_assert, if and while usually contain expressions.
Daniel Jasper8b1c6352013-08-01 17:58:23 +0000119 Contexts.back().IsExpression = true;
Daniel Jasper72ab43b2014-04-14 12:50:02 +0000120 } else if (Line.InPPDirective &&
Daniel Jasper866468a2014-04-14 13:15:29 +0000121 (!Left->Previous ||
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000122 !Left->Previous->isOneOf(tok::identifier,
123 TT_OverloadedOperator))) {
Daniel Jasper72ab43b2014-04-14 12:50:02 +0000124 Contexts.back().IsExpression = true;
Daniel Jasperd46e07e2013-10-20 18:15:30 +0000125 } else if (Left->Previous && Left->Previous->is(tok::r_square) &&
126 Left->Previous->MatchingParen &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000127 Left->Previous->MatchingParen->is(TT_LambdaLSquare)) {
Daniel Jasperd46e07e2013-10-20 18:15:30 +0000128 // This is a parameter list of a lambda expression.
129 Contexts.back().IsExpression = false;
Daniel Jasperc13ee342014-03-27 09:43:54 +0000130 } else if (Contexts[Contexts.size() - 2].CaretFound) {
Daniel Jasperb88b25f2013-12-23 07:29:06 +0000131 // This is the parameter list of an ObjC block.
132 Contexts.back().IsExpression = false;
Daniel Jasper559b63c2014-01-28 20:13:43 +0000133 } else if (Left->Previous && Left->Previous->is(tok::kw___attribute)) {
134 Left->Type = TT_AttributeParen;
Daniel Jaspere1e43192014-04-01 12:55:11 +0000135 } else if (Left->Previous && Left->Previous->IsForEachMacro) {
136 // The first argument to a foreach macro is a declaration.
137 Contexts.back().IsForEachMacro = true;
138 Contexts.back().IsExpression = false;
Daniel Jasperf1f267b2014-10-21 07:57:50 +0000139 } else if (Left->Previous && Left->Previous->MatchingParen &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000140 Left->Previous->MatchingParen->is(TT_ObjCBlockLParen)) {
Daniel Jasperf1f267b2014-10-21 07:57:50 +0000141 Contexts.back().IsExpression = false;
Daniel Jasperd46e07e2013-10-20 18:15:30 +0000142 }
Daniel Jasper8b1c6352013-08-01 17:58:23 +0000143
Daniel Jasperc697ad22013-02-06 10:05:46 +0000144 if (StartsObjCMethodExpr) {
145 Contexts.back().ColonIsObjCMethodExpr = true;
146 Left->Type = TT_ObjCMethodExpr;
147 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000148
Daniel Jasper37194282013-05-28 08:33:00 +0000149 bool MightBeFunctionType = CurrentToken->is(tok::star);
Daniel Jasperb10cbc42013-07-10 14:02:49 +0000150 bool HasMultipleLines = false;
151 bool HasMultipleParametersOnALine = false;
Daniel Jasper2b1865c2015-04-15 07:26:18 +0000152 bool MightBeObjCForRangeLoop =
153 Left->Previous && Left->Previous->is(tok::kw_for);
Craig Topper2145bc02014-05-09 08:15:10 +0000154 while (CurrentToken) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000155 // LookForDecls is set when "if (" has been seen. Check for
156 // 'identifier' '*' 'identifier' followed by not '=' -- this
157 // '*' has to be a binary operator but determineStarAmpUsage() will
158 // categorize it as an unary operator, so set the right type here.
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000159 if (LookForDecls && CurrentToken->Next) {
Alexander Kornienko1efe0a02013-07-04 14:47:51 +0000160 FormatToken *Prev = CurrentToken->getPreviousNonComment();
Alexander Kornienkodd7ece52013-06-07 16:02:52 +0000161 if (Prev) {
Alexander Kornienko1efe0a02013-07-04 14:47:51 +0000162 FormatToken *PrevPrev = Prev->getPreviousNonComment();
Alexander Kornienkodd7ece52013-06-07 16:02:52 +0000163 FormatToken *Next = CurrentToken->Next;
164 if (PrevPrev && PrevPrev->is(tok::identifier) &&
165 Prev->isOneOf(tok::star, tok::amp, tok::ampamp) &&
166 CurrentToken->is(tok::identifier) && Next->isNot(tok::equal)) {
167 Prev->Type = TT_BinaryOperator;
168 LookForDecls = false;
169 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000170 }
171 }
172
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000173 if (CurrentToken->Previous->is(TT_PointerOrReference) &&
Daniel Jasper59036852013-08-12 12:16:34 +0000174 CurrentToken->Previous->Previous->isOneOf(tok::l_paren,
175 tok::coloncolon))
176 MightBeFunctionType = true;
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000177 if (CurrentToken->Previous->is(TT_BinaryOperator))
Daniel Jasper91beebd2014-06-30 13:44:47 +0000178 Contexts.back().IsExpression = true;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000179 if (CurrentToken->is(tok::r_paren)) {
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000180 if (MightBeFunctionType && CurrentToken->Next &&
Daniel Jasper655d96a2013-07-16 11:37:21 +0000181 (CurrentToken->Next->is(tok::l_paren) ||
182 (CurrentToken->Next->is(tok::l_square) &&
183 !Contexts.back().IsExpression)))
Daniel Jasper37194282013-05-28 08:33:00 +0000184 Left->Type = TT_FunctionTypeLParen;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000185 Left->MatchingParen = CurrentToken;
186 CurrentToken->MatchingParen = Left;
187
Daniel Jasper1ac3e052013-02-05 10:07:47 +0000188 if (StartsObjCMethodExpr) {
Daniel Jasperc697ad22013-02-06 10:05:46 +0000189 CurrentToken->Type = TT_ObjCMethodExpr;
Craig Topper2145bc02014-05-09 08:15:10 +0000190 if (Contexts.back().FirstObjCSelectorName) {
Daniel Jasperc697ad22013-02-06 10:05:46 +0000191 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
192 Contexts.back().LongestObjCSelectorName;
Daniel Jasper1ac3e052013-02-05 10:07:47 +0000193 }
194 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000195
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000196 if (Left->is(TT_AttributeParen))
Daniel Jasper559b63c2014-01-28 20:13:43 +0000197 CurrentToken->Type = TT_AttributeParen;
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000198 if (Left->Previous && Left->Previous->is(TT_JavaAnnotation))
Daniel Jasperf1f0c352014-10-21 09:25:39 +0000199 CurrentToken->Type = TT_JavaAnnotation;
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000200 if (Left->Previous && Left->Previous->is(TT_LeadingJavaAnnotation))
Daniel Jaspere9ab42d2014-10-31 18:23:49 +0000201 CurrentToken->Type = TT_LeadingJavaAnnotation;
Daniel Jasper559b63c2014-01-28 20:13:43 +0000202
Daniel Jasperb10cbc42013-07-10 14:02:49 +0000203 if (!HasMultipleLines)
204 Left->PackingKind = PPK_Inconclusive;
205 else if (HasMultipleParametersOnALine)
206 Left->PackingKind = PPK_BinPacked;
207 else
208 Left->PackingKind = PPK_OnePerLine;
209
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000210 next();
211 return true;
212 }
Alexander Kornienko62b85b92013-03-13 14:41:29 +0000213 if (CurrentToken->isOneOf(tok::r_square, tok::r_brace))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000214 return false;
Daniel Jasper2b1865c2015-04-15 07:26:18 +0000215
216 if (CurrentToken->is(tok::l_brace))
Daniel Jasper31745732014-01-19 07:46:32 +0000217 Left->Type = TT_Unknown; // Not TT_ObjCBlockLParen
Daniel Jasperb10cbc42013-07-10 14:02:49 +0000218 if (CurrentToken->is(tok::comma) && CurrentToken->Next &&
219 !CurrentToken->Next->HasUnescapedNewline &&
220 !CurrentToken->Next->isTrailingComment())
221 HasMultipleParametersOnALine = true;
Daniel Jaspercc7bf7f2014-04-03 09:00:49 +0000222 if (CurrentToken->isOneOf(tok::kw_const, tok::kw_auto) ||
Daniel Jasperc580af92014-03-11 09:29:46 +0000223 CurrentToken->isSimpleTypeSpecifier())
224 Contexts.back().IsExpression = false;
Daniel Jasper2b1865c2015-04-15 07:26:18 +0000225 if (CurrentToken->isOneOf(tok::semi, tok::colon))
226 MightBeObjCForRangeLoop = false;
227 if (MightBeObjCForRangeLoop && CurrentToken->is(Keywords.kw_in))
228 CurrentToken->Type = TT_ObjCForIn;
229
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000230 FormatToken *Tok = CurrentToken;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000231 if (!consumeToken())
232 return false;
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000233 updateParameterCount(Left, Tok);
Daniel Jasperb10cbc42013-07-10 14:02:49 +0000234 if (CurrentToken && CurrentToken->HasUnescapedNewline)
235 HasMultipleLines = true;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000236 }
237 return false;
238 }
239
240 bool parseSquare() {
241 if (!CurrentToken)
242 return false;
243
Alexander Kornienkoafaa8f52013-06-17 13:19:53 +0000244 // A '[' could be an index subscript (after an identifier or after
Nico Weber2a726b62013-02-10 02:08:05 +0000245 // ')' or ']'), it could be the start of an Objective-C method
246 // expression, or it could the the start of an Objective-C array literal.
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000247 FormatToken *Left = CurrentToken->Previous;
Alexander Kornienko1efe0a02013-07-04 14:47:51 +0000248 FormatToken *Parent = Left->getPreviousNonComment();
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000249 bool StartsObjCMethodExpr =
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000250 Contexts.back().CanBeExpression && Left->isNot(TT_LambdaLSquare) &&
Daniel Jasper89519082014-05-09 10:26:08 +0000251 CurrentToken->isNot(tok::l_brace) &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000252 (!Parent ||
253 Parent->isOneOf(tok::colon, tok::l_square, tok::l_paren,
254 tok::kw_return, tok::kw_throw) ||
255 Parent->isUnaryOperator() ||
256 Parent->isOneOf(TT_ObjCForIn, TT_CastRParen) ||
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000257 getBinOpPrecedence(Parent->Tok.getKind(), true, true) > prec::Unknown);
Daniel Jasper40aacf42013-03-14 13:45:21 +0000258 ScopedContextCreator ContextCreator(*this, tok::l_square, 10);
Daniel Jasper97b89482013-03-13 07:49:51 +0000259 Contexts.back().IsExpression = true;
Daniel Jaspera1ea4cb2013-10-26 17:00:22 +0000260 bool ColonFound = false;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000261
Daniel Jasperc697ad22013-02-06 10:05:46 +0000262 if (StartsObjCMethodExpr) {
263 Contexts.back().ColonIsObjCMethodExpr = true;
264 Left->Type = TT_ObjCMethodExpr;
Daniel Jasper1db6c382013-10-22 15:30:28 +0000265 } else if (Parent && Parent->is(tok::at)) {
266 Left->Type = TT_ArrayInitializerLSquare;
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000267 } else if (Left->is(TT_Unknown)) {
Daniel Jasper1db6c382013-10-22 15:30:28 +0000268 Left->Type = TT_ArraySubscriptLSquare;
Daniel Jasperc697ad22013-02-06 10:05:46 +0000269 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000270
Craig Topper2145bc02014-05-09 08:15:10 +0000271 while (CurrentToken) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000272 if (CurrentToken->is(tok::r_square)) {
Daniel Jasper9a8d48b2013-09-05 10:04:31 +0000273 if (CurrentToken->Next && CurrentToken->Next->is(tok::l_paren) &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000274 Left->is(TT_ObjCMethodExpr)) {
Nico Weber5d2624e2013-02-06 06:20:11 +0000275 // An ObjC method call is rarely followed by an open parenthesis.
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000276 // FIXME: Do we incorrectly label ":" with this?
277 StartsObjCMethodExpr = false;
278 Left->Type = TT_Unknown;
279 }
Daniel Jasper139d4a32014-04-08 13:07:41 +0000280 if (StartsObjCMethodExpr && CurrentToken->Previous != Left) {
Daniel Jasperc697ad22013-02-06 10:05:46 +0000281 CurrentToken->Type = TT_ObjCMethodExpr;
Nico Weber5d2624e2013-02-06 06:20:11 +0000282 // determineStarAmpUsage() thinks that '*' '[' is allocating an
283 // array of pointers, but if '[' starts a selector then '*' is a
284 // binary operator.
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000285 if (Parent && Parent->is(TT_PointerOrReference))
Nico Weberac9bde22013-02-06 16:54:35 +0000286 Parent->Type = TT_BinaryOperator;
Daniel Jasper3a9370c2013-02-04 07:21:18 +0000287 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000288 Left->MatchingParen = CurrentToken;
289 CurrentToken->MatchingParen = Left;
Craig Topper2145bc02014-05-09 08:15:10 +0000290 if (Contexts.back().FirstObjCSelectorName) {
Daniel Jasperc697ad22013-02-06 10:05:46 +0000291 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
292 Contexts.back().LongestObjCSelectorName;
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000293 if (Left->BlockParameterCount > 1)
Daniel Jasperb88b25f2013-12-23 07:29:06 +0000294 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = 0;
295 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000296 next();
297 return true;
298 }
Alexander Kornienko62b85b92013-03-13 14:41:29 +0000299 if (CurrentToken->isOneOf(tok::r_paren, tok::r_brace))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000300 return false;
Daniel Jasperea772b4d2014-10-16 08:38:51 +0000301 if (CurrentToken->is(tok::colon)) {
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000302 if (Left->is(TT_ArraySubscriptLSquare)) {
Daniel Jasperea772b4d2014-10-16 08:38:51 +0000303 Left->Type = TT_ObjCMethodExpr;
304 StartsObjCMethodExpr = true;
305 Contexts.back().ColonIsObjCMethodExpr = true;
306 if (Parent && Parent->is(tok::r_paren))
307 Parent->Type = TT_CastRParen;
308 }
Daniel Jaspera1ea4cb2013-10-26 17:00:22 +0000309 ColonFound = true;
Daniel Jasperea772b4d2014-10-16 08:38:51 +0000310 }
Daniel Jasper1db6c382013-10-22 15:30:28 +0000311 if (CurrentToken->is(tok::comma) &&
Daniel Jaspera0e9be22014-01-28 18:51:11 +0000312 Style.Language != FormatStyle::LK_Proto &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000313 (Left->is(TT_ArraySubscriptLSquare) ||
314 (Left->is(TT_ObjCMethodExpr) && !ColonFound)))
Daniel Jasper1db6c382013-10-22 15:30:28 +0000315 Left->Type = TT_ArrayInitializerLSquare;
Nico Weberbeb03932015-01-09 23:25:06 +0000316 FormatToken *Tok = CurrentToken;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000317 if (!consumeToken())
318 return false;
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000319 updateParameterCount(Left, Tok);
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000320 }
321 return false;
322 }
323
324 bool parseBrace() {
Craig Topper2145bc02014-05-09 08:15:10 +0000325 if (CurrentToken) {
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000326 FormatToken *Left = CurrentToken->Previous;
Daniel Jasperc13ee342014-03-27 09:43:54 +0000327
328 if (Contexts.back().CaretFound)
329 Left->Type = TT_ObjCBlockLBrace;
330 Contexts.back().CaretFound = false;
331
Daniel Jasperb596fb22013-10-24 10:31:50 +0000332 ScopedContextCreator ContextCreator(*this, tok::l_brace, 1);
333 Contexts.back().ColonIsDictLiteral = true;
Daniel Jasper39485162014-05-22 09:00:33 +0000334 if (Left->BlockKind == BK_BracedInit)
335 Contexts.back().IsExpression = true;
Nico Weberced7d412013-05-26 05:39:26 +0000336
Craig Topper2145bc02014-05-09 08:15:10 +0000337 while (CurrentToken) {
Daniel Jasper8e357692013-05-06 08:27:33 +0000338 if (CurrentToken->is(tok::r_brace)) {
339 Left->MatchingParen = CurrentToken;
340 CurrentToken->MatchingParen = Left;
341 next();
342 return true;
343 }
344 if (CurrentToken->isOneOf(tok::r_paren, tok::r_square))
345 return false;
346 updateParameterCount(Left, CurrentToken);
Daniel Jasper497d9fd2014-08-15 05:00:35 +0000347 if (CurrentToken->isOneOf(tok::colon, tok::l_brace)) {
348 FormatToken *Previous = CurrentToken->getPreviousNonComment();
Daniel Jasper168c8aa2014-08-27 11:53:26 +0000349 if ((CurrentToken->is(tok::colon) ||
350 Style.Language == FormatStyle::LK_Proto) &&
351 Previous->is(tok::identifier))
Daniel Jasper497d9fd2014-08-15 05:00:35 +0000352 Previous->Type = TT_SelectorName;
Daniel Jasper739ec532015-04-04 07:56:55 +0000353 if (CurrentToken->is(tok::colon) ||
354 Style.Language == FormatStyle::LK_JavaScript)
Daniel Jasper497d9fd2014-08-15 05:00:35 +0000355 Left->Type = TT_DictLiteral;
Daniel Jasper17062ff2014-06-10 14:44:02 +0000356 }
Daniel Jasper8e357692013-05-06 08:27:33 +0000357 if (!consumeToken())
358 return false;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000359 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000360 }
361 return true;
362 }
Daniel Jasperdc7d5812013-02-20 12:56:39 +0000363
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000364 void updateParameterCount(FormatToken *Left, FormatToken *Current) {
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000365 if (Current->is(TT_LambdaLSquare) ||
366 (Current->is(tok::caret) && Current->is(TT_UnaryOperator)) ||
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000367 (Style.Language == FormatStyle::LK_JavaScript &&
Daniel Jasperd0ec0d62014-11-04 12:41:02 +0000368 Current->is(Keywords.kw_function))) {
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000369 ++Left->BlockParameterCount;
370 }
Daniel Jasperb10cbc42013-07-10 14:02:49 +0000371 if (Current->is(tok::comma)) {
Daniel Jaspere11095a2013-02-14 15:01:34 +0000372 ++Left->ParameterCount;
Daniel Jasper8de9ed02013-08-22 15:00:41 +0000373 if (!Left->Role)
374 Left->Role.reset(new CommaSeparatedList(Style));
375 Left->Role->CommaFound(Current);
Daniel Jasperb10cbc42013-07-10 14:02:49 +0000376 } else if (Left->ParameterCount == 0 && Current->isNot(tok::comment)) {
Daniel Jaspere11095a2013-02-14 15:01:34 +0000377 Left->ParameterCount = 1;
Daniel Jasperb10cbc42013-07-10 14:02:49 +0000378 }
Daniel Jaspere11095a2013-02-14 15:01:34 +0000379 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000380
381 bool parseConditional() {
Craig Topper2145bc02014-05-09 08:15:10 +0000382 while (CurrentToken) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000383 if (CurrentToken->is(tok::colon)) {
384 CurrentToken->Type = TT_ConditionalExpr;
385 next();
386 return true;
387 }
388 if (!consumeToken())
389 return false;
390 }
391 return false;
392 }
393
394 bool parseTemplateDeclaration() {
Craig Topper2145bc02014-05-09 08:15:10 +0000395 if (CurrentToken && CurrentToken->is(tok::less)) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000396 CurrentToken->Type = TT_TemplateOpener;
397 next();
398 if (!parseAngle())
399 return false;
Craig Topper2145bc02014-05-09 08:15:10 +0000400 if (CurrentToken)
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000401 CurrentToken->Previous->ClosesTemplateDeclaration = true;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000402 return true;
403 }
404 return false;
405 }
406
407 bool consumeToken() {
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000408 FormatToken *Tok = CurrentToken;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000409 next();
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000410 switch (Tok->Tok.getKind()) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000411 case tok::plus:
412 case tok::minus:
Craig Topper2145bc02014-05-09 08:15:10 +0000413 if (!Tok->Previous && Line.MustBeDeclaration)
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000414 Tok->Type = TT_ObjCMethodSpecifier;
415 break;
416 case tok::colon:
Craig Topper2145bc02014-05-09 08:15:10 +0000417 if (!Tok->Previous)
Daniel Jasper850677d2013-03-18 12:50:26 +0000418 return false;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000419 // Colons from ?: are handled in parseConditional().
Daniel Jaspera74f5072015-04-13 15:01:40 +0000420 if (Style.Language == FormatStyle::LK_JavaScript) {
421 if (Contexts.back().ColonIsForRangeExpr ||
422 (Contexts.size() == 1 &&
423 !Line.First->isOneOf(tok::kw_enum, tok::kw_case)) ||
Daniel Jasperd9309772015-04-13 15:03:30 +0000424 Contexts.back().ContextKind == tok::l_paren ||
425 Contexts.back().ContextKind == tok::l_square) {
Daniel Jaspera74f5072015-04-13 15:01:40 +0000426 Tok->Type = TT_JsTypeColon;
427 break;
428 }
429 }
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000430 if (Contexts.back().ColonIsDictLiteral) {
Daniel Jasperb596fb22013-10-24 10:31:50 +0000431 Tok->Type = TT_DictLiteral;
Daniel Jasperc697ad22013-02-06 10:05:46 +0000432 } else if (Contexts.back().ColonIsObjCMethodExpr ||
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000433 Line.First->is(TT_ObjCMethodSpecifier)) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000434 Tok->Type = TT_ObjCMethodExpr;
Daniel Jasper17062ff2014-06-10 14:44:02 +0000435 Tok->Previous->Type = TT_SelectorName;
Alexander Kornienko39856b72013-09-10 09:38:25 +0000436 if (Tok->Previous->ColumnWidth >
Alexander Kornienkoffcc0102013-06-05 14:09:10 +0000437 Contexts.back().LongestObjCSelectorName) {
Alexander Kornienko60d1b042013-10-10 13:36:20 +0000438 Contexts.back().LongestObjCSelectorName = Tok->Previous->ColumnWidth;
Alexander Kornienkoffcc0102013-06-05 14:09:10 +0000439 }
Craig Topper2145bc02014-05-09 08:15:10 +0000440 if (!Contexts.back().FirstObjCSelectorName)
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000441 Contexts.back().FirstObjCSelectorName = Tok->Previous;
Daniel Jasperc697ad22013-02-06 10:05:46 +0000442 } else if (Contexts.back().ColonIsForRangeExpr) {
Daniel Jaspera74f5072015-04-13 15:01:40 +0000443 Tok->Type = TT_RangeBasedForLoopColon;
Daniel Jasperb05a81d2014-05-09 13:11:16 +0000444 } else if (CurrentToken && CurrentToken->is(tok::numeric_constant)) {
Alexander Kornienko60d1b042013-10-10 13:36:20 +0000445 Tok->Type = TT_BitFieldColon;
Daniel Jasperd39312ec2014-05-28 10:09:11 +0000446 } else if (Contexts.size() == 1 &&
447 !Line.First->isOneOf(tok::kw_enum, tok::kw_case)) {
Daniel Jaspera74f5072015-04-13 15:01:40 +0000448 if (Tok->Previous->is(tok::r_paren))
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000449 Tok->Type = TT_CtorInitializerColon;
450 else
451 Tok->Type = TT_InheritanceColon;
Daniel Jasper78580792014-10-20 12:01:45 +0000452 } else if (Tok->Previous->is(tok::identifier) && Tok->Next &&
453 Tok->Next->isOneOf(tok::r_paren, tok::comma)) {
454 // This handles a special macro in ObjC code where selectors including
455 // the colon are passed as macro arguments.
456 Tok->Type = TT_ObjCMethodExpr;
Daniel Jasper40aacf42013-03-14 13:45:21 +0000457 } else if (Contexts.back().ContextKind == tok::l_paren) {
Daniel Jaspera74f5072015-04-13 15:01:40 +0000458 Tok->Type = TT_InlineASMColon;
Daniel Jasper1ac3e052013-02-05 10:07:47 +0000459 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000460 break;
461 case tok::kw_if:
462 case tok::kw_while:
Craig Topper2145bc02014-05-09 08:15:10 +0000463 if (CurrentToken && CurrentToken->is(tok::l_paren)) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000464 next();
Nico Weber9096fc02013-06-26 00:30:14 +0000465 if (!parseParens(/*LookForDecls=*/true))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000466 return false;
467 }
468 break;
469 case tok::kw_for:
Daniel Jasperc697ad22013-02-06 10:05:46 +0000470 Contexts.back().ColonIsForRangeExpr = true;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000471 next();
472 if (!parseParens())
473 return false;
474 break;
475 case tok::l_paren:
476 if (!parseParens())
477 return false;
Daniel Jasperbc5cb4e2013-11-07 17:43:07 +0000478 if (Line.MustBeDeclaration && Contexts.size() == 1 &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000479 !Contexts.back().IsExpression && Line.First->isNot(TT_ObjCProperty) &&
Daniel Jaspera831c582015-01-14 09:47:57 +0000480 (!Tok->Previous ||
481 !Tok->Previous->isOneOf(tok::kw_decltype, TT_LeadingJavaAnnotation)))
Daniel Jasper26d1b1d2013-02-24 18:54:32 +0000482 Line.MightBeFunctionDecl = true;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000483 break;
484 case tok::l_square:
485 if (!parseSquare())
486 return false;
487 break;
488 case tok::l_brace:
489 if (!parseBrace())
490 return false;
491 break;
492 case tok::less:
Daniel Jasperb13135b2015-01-08 08:48:21 +0000493 if ((!Tok->Previous ||
494 (!Tok->Previous->Tok.isLiteral() &&
495 !(Tok->Previous->is(tok::r_paren) && Contexts.size() > 1))) &&
496 parseAngle()) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000497 Tok->Type = TT_TemplateOpener;
Daniel Jasperb13135b2015-01-08 08:48:21 +0000498 } else {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000499 Tok->Type = TT_BinaryOperator;
500 CurrentToken = Tok;
501 next();
502 }
503 break;
504 case tok::r_paren:
505 case tok::r_square:
506 return false;
507 case tok::r_brace:
508 // Lines can start with '}'.
Craig Topper2145bc02014-05-09 08:15:10 +0000509 if (Tok->Previous)
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000510 return false;
511 break;
512 case tok::greater:
513 Tok->Type = TT_BinaryOperator;
514 break;
515 case tok::kw_operator:
Daniel Jasper42401c82013-09-02 09:20:39 +0000516 while (CurrentToken &&
517 !CurrentToken->isOneOf(tok::l_paren, tok::semi, tok::r_paren)) {
Alexander Kornienko62b85b92013-03-13 14:41:29 +0000518 if (CurrentToken->isOneOf(tok::star, tok::amp))
Daniel Jasper35d2dc72013-02-11 08:01:18 +0000519 CurrentToken->Type = TT_PointerOrReference;
520 consumeToken();
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000521 if (CurrentToken && CurrentToken->Previous->is(TT_BinaryOperator))
Daniel Jasperd215b8b2013-08-28 07:27:35 +0000522 CurrentToken->Previous->Type = TT_OverloadedOperator;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000523 }
Daniel Jasper8f9624b2013-05-10 07:59:58 +0000524 if (CurrentToken) {
Daniel Jasper35d2dc72013-02-11 08:01:18 +0000525 CurrentToken->Type = TT_OverloadedOperatorLParen;
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000526 if (CurrentToken->Previous->is(TT_BinaryOperator))
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000527 CurrentToken->Previous->Type = TT_OverloadedOperator;
Daniel Jasper8f9624b2013-05-10 07:59:58 +0000528 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000529 break;
530 case tok::question:
Daniel Jaspera74f5072015-04-13 15:01:40 +0000531 if (Style.Language == FormatStyle::LK_JavaScript && Tok->Next &&
532 Tok->Next->isOneOf(tok::colon, tok::semi, tok::r_paren,
533 tok::r_brace)) {
534 // Question marks before semicolons, colons, commas, etc. indicate
535 // optional types (fields, parameters), e.g.
536 // `function(x?: string, y?) {...}` or `class X {y?;}`
537 Tok->Type = TT_JsTypeOptionalQuestion;
538 break;
539 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000540 parseConditional();
541 break;
542 case tok::kw_template:
543 parseTemplateDeclaration();
544 break;
Daniel Jaspera628c982013-04-03 13:36:17 +0000545 case tok::comma:
Daniel Jaspere4ab49e2015-04-20 12:54:29 +0000546 if (Contexts.back().InCtorInitializer)
547 Tok->Type = TT_CtorInitializerComma;
548 else if (Contexts.back().FirstStartOfName && Contexts.size() == 1) {
Daniel Jaspera628c982013-04-03 13:36:17 +0000549 Contexts.back().FirstStartOfName->PartOfMultiVariableDeclStmt = true;
Daniel Jasperbea1ab42015-03-01 18:55:26 +0000550 Line.IsMultiVariableDeclStmt = true;
551 }
Daniel Jaspere1e43192014-04-01 12:55:11 +0000552 if (Contexts.back().IsForEachMacro)
553 Contexts.back().IsExpression = true;
Daniel Jaspera628c982013-04-03 13:36:17 +0000554 break;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000555 default:
556 break;
557 }
558 return true;
559 }
560
561 void parseIncludeDirective() {
Craig Topper2145bc02014-05-09 08:15:10 +0000562 if (CurrentToken && CurrentToken->is(tok::less)) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000563 next();
Craig Topper2145bc02014-05-09 08:15:10 +0000564 while (CurrentToken) {
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000565 if (CurrentToken->isNot(tok::comment) || CurrentToken->Next)
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000566 CurrentToken->Type = TT_ImplicitStringLiteral;
567 next();
568 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000569 }
570 }
571
572 void parseWarningOrError() {
573 next();
574 // We still want to format the whitespace left of the first token of the
575 // warning or error.
576 next();
Craig Topper2145bc02014-05-09 08:15:10 +0000577 while (CurrentToken) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000578 CurrentToken->Type = TT_ImplicitStringLiteral;
579 next();
580 }
581 }
582
Daniel Jasperdc32c1b2014-01-09 13:56:49 +0000583 void parsePragma() {
584 next(); // Consume "pragma".
Daniel Jasperee4a8a12015-04-22 09:45:42 +0000585 if (CurrentToken &&
586 CurrentToken->isOneOf(Keywords.kw_mark, Keywords.kw_option)) {
587 bool IsMark = CurrentToken->is(Keywords.kw_mark);
Daniel Jasperdc32c1b2014-01-09 13:56:49 +0000588 next(); // Consume "mark".
589 next(); // Consume first token (so we fix leading whitespace).
Craig Topper2145bc02014-05-09 08:15:10 +0000590 while (CurrentToken) {
Daniel Jasperee4a8a12015-04-22 09:45:42 +0000591 if (IsMark || CurrentToken->Previous->is(TT_BinaryOperator))
592 CurrentToken->Type = TT_ImplicitStringLiteral;
Daniel Jasperdc32c1b2014-01-09 13:56:49 +0000593 next();
594 }
595 }
596 }
597
Daniel Jasper616de8642014-11-23 16:46:28 +0000598 LineType parsePreprocessorDirective() {
599 LineType Type = LT_PreprocessorDirective;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000600 next();
Craig Topper2145bc02014-05-09 08:15:10 +0000601 if (!CurrentToken)
Daniel Jasper616de8642014-11-23 16:46:28 +0000602 return Type;
Alexander Kornienko384b40b2013-10-11 21:43:05 +0000603 if (CurrentToken->Tok.is(tok::numeric_constant)) {
604 CurrentToken->SpacesRequiredBefore = 1;
Daniel Jasper616de8642014-11-23 16:46:28 +0000605 return Type;
Alexander Kornienko384b40b2013-10-11 21:43:05 +0000606 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000607 // Hashes in the middle of a line can lead to any strange token
608 // sequence.
Craig Topper2145bc02014-05-09 08:15:10 +0000609 if (!CurrentToken->Tok.getIdentifierInfo())
Daniel Jasper616de8642014-11-23 16:46:28 +0000610 return Type;
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000611 switch (CurrentToken->Tok.getIdentifierInfo()->getPPKeywordID()) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000612 case tok::pp_include:
613 case tok::pp_import:
Daniel Jasper343643b2014-08-13 08:29:18 +0000614 next();
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000615 parseIncludeDirective();
Daniel Jasper616de8642014-11-23 16:46:28 +0000616 Type = LT_ImportStatement;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000617 break;
618 case tok::pp_error:
619 case tok::pp_warning:
620 parseWarningOrError();
621 break;
Daniel Jasperdc32c1b2014-01-09 13:56:49 +0000622 case tok::pp_pragma:
623 parsePragma();
624 break;
Daniel Jasper4431aa92013-04-23 13:54:04 +0000625 case tok::pp_if:
626 case tok::pp_elif:
Daniel Jasper7cfde412014-01-21 08:56:09 +0000627 Contexts.back().IsExpression = true;
Daniel Jasper4431aa92013-04-23 13:54:04 +0000628 parseLine();
629 break;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000630 default:
631 break;
632 }
Craig Topper2145bc02014-05-09 08:15:10 +0000633 while (CurrentToken)
Daniel Jaspera885dbe2013-02-05 09:34:14 +0000634 next();
Daniel Jasper616de8642014-11-23 16:46:28 +0000635 return Type;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000636 }
637
Nico Weber44449172013-02-12 16:17:07 +0000638public:
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000639 LineType parseLine() {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000640 if (CurrentToken->is(tok::hash)) {
Daniel Jasper616de8642014-11-23 16:46:28 +0000641 return parsePreprocessorDirective();
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000642 }
Daniel Jasper7cfde412014-01-21 08:56:09 +0000643
Daniel Jasper47ef6dd2014-01-17 16:21:39 +0000644 // Directly allow to 'import <string-literal>' to support protocol buffer
645 // definitions (code.google.com/p/protobuf) or missing "#" (either way we
646 // should not break the line).
647 IdentifierInfo *Info = CurrentToken->Tok.getIdentifierInfo();
Daniel Jasper9b9e0762014-11-26 18:03:42 +0000648 if ((Style.Language == FormatStyle::LK_Java &&
649 CurrentToken->is(Keywords.kw_package)) ||
650 (Info && Info->getPPKeywordID() == tok::pp_import &&
Daniel Jasper86ee0b62014-12-04 08:57:27 +0000651 CurrentToken->Next &&
Daniel Jasper16dbe0b2015-01-14 10:02:49 +0000652 CurrentToken->Next->isOneOf(tok::string_literal, tok::identifier,
653 tok::kw_static))) {
Daniel Jasper343643b2014-08-13 08:29:18 +0000654 next();
Daniel Jasper47ef6dd2014-01-17 16:21:39 +0000655 parseIncludeDirective();
Daniel Jasper616de8642014-11-23 16:46:28 +0000656 return LT_ImportStatement;
Daniel Jasper343643b2014-08-13 08:29:18 +0000657 }
658
659 // If this line starts and ends in '<' and '>', respectively, it is likely
660 // part of "#define <a/b.h>".
661 if (CurrentToken->is(tok::less) && Line.Last->is(tok::greater)) {
662 parseIncludeDirective();
Daniel Jasper616de8642014-11-23 16:46:28 +0000663 return LT_ImportStatement;
Daniel Jasper343643b2014-08-13 08:29:18 +0000664 }
Daniel Jasper47ef6dd2014-01-17 16:21:39 +0000665
Daniel Jasper616de8642014-11-23 16:46:28 +0000666 bool KeywordVirtualFound = false;
667 bool ImportStatement = false;
Craig Topper2145bc02014-05-09 08:15:10 +0000668 while (CurrentToken) {
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000669 if (CurrentToken->is(tok::kw_virtual))
670 KeywordVirtualFound = true;
Daniel Jasper616de8642014-11-23 16:46:28 +0000671 if (IsImportStatement(*CurrentToken))
672 ImportStatement = true;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000673 if (!consumeToken())
674 return LT_Invalid;
675 }
676 if (KeywordVirtualFound)
677 return LT_VirtualFunctionDecl;
Daniel Jasper616de8642014-11-23 16:46:28 +0000678 if (ImportStatement)
679 return LT_ImportStatement;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000680
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000681 if (Line.First->is(TT_ObjCMethodSpecifier)) {
Craig Topper2145bc02014-05-09 08:15:10 +0000682 if (Contexts.back().FirstObjCSelectorName)
Daniel Jasperc697ad22013-02-06 10:05:46 +0000683 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
684 Contexts.back().LongestObjCSelectorName;
Daniel Jasper1ac3e052013-02-05 10:07:47 +0000685 return LT_ObjCMethodDecl;
686 }
687
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000688 return LT_Other;
689 }
690
Nico Weber44449172013-02-12 16:17:07 +0000691private:
Daniel Jasper616de8642014-11-23 16:46:28 +0000692 bool IsImportStatement(const FormatToken &Tok) {
693 // FIXME: Closure-library specific stuff should not be hard-coded but be
694 // configurable.
695 return Style.Language == FormatStyle::LK_JavaScript &&
696 Tok.TokenText == "goog" && Tok.Next && Tok.Next->is(tok::period) &&
697 Tok.Next->Next && (Tok.Next->Next->TokenText == "module" ||
698 Tok.Next->Next->TokenText == "require" ||
Daniel Jasper53c38f42014-11-27 14:46:03 +0000699 Tok.Next->Next->TokenText == "provide") &&
700 Tok.Next->Next->Next && Tok.Next->Next->Next->is(tok::l_paren);
Daniel Jasper616de8642014-11-23 16:46:28 +0000701 }
702
Manuel Klimek819788d2014-03-18 11:22:45 +0000703 void resetTokenMetadata(FormatToken *Token) {
Daniel Jasperb05a81d2014-05-09 13:11:16 +0000704 if (!Token)
705 return;
Manuel Klimek819788d2014-03-18 11:22:45 +0000706
707 // Reset token type in case we have already looked at it and then
708 // recovered from an error (e.g. failure to find the matching >).
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000709 if (!CurrentToken->isOneOf(TT_LambdaLSquare, TT_FunctionLBrace,
710 TT_ImplicitStringLiteral, TT_RegexLiteral,
711 TT_TrailingReturnArrow))
Manuel Klimek819788d2014-03-18 11:22:45 +0000712 CurrentToken->Type = TT_Unknown;
David Blaikie3875a822014-07-19 01:06:45 +0000713 CurrentToken->Role.reset();
Daniel Jasperd1debfc2015-01-21 18:04:02 +0000714 CurrentToken->MatchingParen = nullptr;
Manuel Klimek819788d2014-03-18 11:22:45 +0000715 CurrentToken->FakeLParens.clear();
716 CurrentToken->FakeRParens = 0;
717 }
718
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000719 void next() {
Craig Topper2145bc02014-05-09 08:15:10 +0000720 if (CurrentToken) {
Daniel Jasper63af7c42013-12-09 14:40:19 +0000721 CurrentToken->NestingLevel = Contexts.size() - 1;
Daniel Jasper78b45332014-08-14 10:52:56 +0000722 CurrentToken->BindingStrength = Contexts.back().BindingStrength;
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000723 modifyContext(*CurrentToken);
Daniel Jasper78b45332014-08-14 10:52:56 +0000724 determineTokenType(*CurrentToken);
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000725 CurrentToken = CurrentToken->Next;
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000726 }
Daniel Jasper5065bc42013-02-18 12:44:35 +0000727
Manuel Klimek819788d2014-03-18 11:22:45 +0000728 resetTokenMetadata(CurrentToken);
Daniel Jasper7a6d09b2013-01-29 21:01:14 +0000729 }
730
Daniel Jasperc697ad22013-02-06 10:05:46 +0000731 /// \brief A struct to hold information valid in a specific context, e.g.
732 /// a pair of parenthesis.
733 struct Context {
Daniel Jasper40aacf42013-03-14 13:45:21 +0000734 Context(tok::TokenKind ContextKind, unsigned BindingStrength,
735 bool IsExpression)
736 : ContextKind(ContextKind), BindingStrength(BindingStrength),
Daniel Jasper2b1865c2015-04-15 07:26:18 +0000737 IsExpression(IsExpression) {}
Daniel Jasper3a9370c2013-02-04 07:21:18 +0000738
Daniel Jasper40aacf42013-03-14 13:45:21 +0000739 tok::TokenKind ContextKind;
Daniel Jasperc697ad22013-02-06 10:05:46 +0000740 unsigned BindingStrength;
Daniel Jasperc697ad22013-02-06 10:05:46 +0000741 bool IsExpression;
Daniel Jasper2b1865c2015-04-15 07:26:18 +0000742 unsigned LongestObjCSelectorName = 0;
743 bool ColonIsForRangeExpr = false;
744 bool ColonIsDictLiteral = false;
745 bool ColonIsObjCMethodExpr = false;
746 FormatToken *FirstObjCSelectorName = nullptr;
747 FormatToken *FirstStartOfName = nullptr;
748 bool CanBeExpression = true;
749 bool InTemplateArgument = false;
750 bool InCtorInitializer = false;
751 bool CaretFound = false;
752 bool IsForEachMacro = false;
Daniel Jasperc697ad22013-02-06 10:05:46 +0000753 };
754
755 /// \brief Puts a new \c Context onto the stack \c Contexts for the lifetime
756 /// of each instance.
757 struct ScopedContextCreator {
758 AnnotatingParser &P;
759
Daniel Jasper40aacf42013-03-14 13:45:21 +0000760 ScopedContextCreator(AnnotatingParser &P, tok::TokenKind ContextKind,
761 unsigned Increase)
762 : P(P) {
Daniel Jasper3ac9b9e2013-07-08 14:34:09 +0000763 P.Contexts.push_back(Context(ContextKind,
764 P.Contexts.back().BindingStrength + Increase,
765 P.Contexts.back().IsExpression));
Daniel Jasperc697ad22013-02-06 10:05:46 +0000766 }
767
768 ~ScopedContextCreator() { P.Contexts.pop_back(); }
769 };
Daniel Jasper3a9370c2013-02-04 07:21:18 +0000770
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000771 void modifyContext(const FormatToken &Current) {
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000772 if (Current.getPrecedence() == prec::Assignment &&
Daniel Jasper75092162015-01-23 19:04:49 +0000773 !Line.First->isOneOf(tok::kw_template, tok::kw_using) &&
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000774 (!Current.Previous || Current.Previous->isNot(tok::kw_operator))) {
Daniel Jasperc697ad22013-02-06 10:05:46 +0000775 Contexts.back().IsExpression = true;
Daniel Jasper75092162015-01-23 19:04:49 +0000776 if (!Line.First->is(TT_UnaryOperator)) {
777 for (FormatToken *Previous = Current.Previous;
778 Previous && !Previous->isOneOf(tok::comma, tok::semi);
779 Previous = Previous->Previous) {
780 if (Previous->isOneOf(tok::r_square, tok::r_paren)) {
781 Previous = Previous->MatchingParen;
782 if (!Previous)
783 break;
784 }
Daniel Jasperdc4f7252015-03-11 12:59:49 +0000785 if (Previous->opensScope())
786 break;
Daniel Jasper75092162015-01-23 19:04:49 +0000787 if (Previous->isOneOf(TT_BinaryOperator, TT_UnaryOperator) &&
Daniel Jasper1c220482015-02-25 10:30:06 +0000788 Previous->isOneOf(tok::star, tok::amp, tok::ampamp) &&
789 Previous->Previous && Previous->Previous->isNot(tok::equal))
Daniel Jasper75092162015-01-23 19:04:49 +0000790 Previous->Type = TT_PointerOrReference;
Manuel Klimek5f594f82014-08-13 14:00:41 +0000791 }
Daniel Jasper3a9370c2013-02-04 07:21:18 +0000792 }
Daniel Jasper3682fcd2013-12-16 08:36:18 +0000793 } else if (Current.isOneOf(tok::kw_return, tok::kw_throw)) {
Daniel Jasperc697ad22013-02-06 10:05:46 +0000794 Contexts.back().IsExpression = true;
Daniel Jasperbcb55ee2014-11-21 14:08:38 +0000795 } else if (Current.is(TT_TrailingReturnArrow)) {
796 Contexts.back().IsExpression = false;
Daniel Jasper3682fcd2013-12-16 08:36:18 +0000797 } else if (Current.is(tok::l_paren) && !Line.MustBeDeclaration &&
Dinesh Dwivedi2e92e662014-05-06 11:46:49 +0000798 !Line.InPPDirective &&
799 (!Current.Previous ||
800 Current.Previous->isNot(tok::kw_decltype))) {
Daniel Jasper3682fcd2013-12-16 08:36:18 +0000801 bool ParametersOfFunctionType =
802 Current.Previous && Current.Previous->is(tok::r_paren) &&
803 Current.Previous->MatchingParen &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000804 Current.Previous->MatchingParen->is(TT_FunctionTypeLParen);
Daniel Jasper3682fcd2013-12-16 08:36:18 +0000805 bool IsForOrCatch = Current.Previous &&
806 Current.Previous->isOneOf(tok::kw_for, tok::kw_catch);
807 Contexts.back().IsExpression = !ParametersOfFunctionType && !IsForOrCatch;
Alexander Kornienko62b85b92013-03-13 14:41:29 +0000808 } else if (Current.isOneOf(tok::r_paren, tok::greater, tok::comma)) {
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000809 for (FormatToken *Previous = Current.Previous;
Alexander Kornienko62b85b92013-03-13 14:41:29 +0000810 Previous && Previous->isOneOf(tok::star, tok::amp);
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000811 Previous = Previous->Previous)
Nico Weber44449172013-02-12 16:17:07 +0000812 Previous->Type = TT_PointerOrReference;
Daniel Jasper6a3fd832014-11-17 13:55:04 +0000813 if (Line.MustBeDeclaration)
Daniel Jaspere1e348b2014-11-17 18:42:22 +0000814 Contexts.back().IsExpression = Contexts.front().InCtorInitializer;
Manuel Klimek6e6310e2013-05-29 14:47:47 +0000815 } else if (Current.Previous &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000816 Current.Previous->is(TT_CtorInitializerColon)) {
Daniel Jasper5065bc42013-02-18 12:44:35 +0000817 Contexts.back().IsExpression = true;
Daniel Jaspere33d4af2013-07-26 16:56:36 +0000818 Contexts.back().InCtorInitializer = true;
Daniel Jasper97b89482013-03-13 07:49:51 +0000819 } else if (Current.is(tok::kw_new)) {
820 Contexts.back().CanBeExpression = false;
Daniel Jaspera98da3d2013-11-07 19:56:07 +0000821 } else if (Current.is(tok::semi) || Current.is(tok::exclaim)) {
Daniel Jasperc37de302013-05-03 14:41:24 +0000822 // This should be the condition or increment in a for-loop.
823 Contexts.back().IsExpression = true;
Nico Weber44449172013-02-12 16:17:07 +0000824 }
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000825 }
Daniel Jasper3a9370c2013-02-04 07:21:18 +0000826
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000827 void determineTokenType(FormatToken &Current) {
828 if (!Current.is(TT_Unknown))
829 // The token type is already known.
830 return;
831
832 // Line.MightBeFunctionDecl can only be true after the parentheses of a
833 // function declaration have been found. In this case, 'Current' is a
834 // trailing token of this declaration and thus cannot be a name.
835 if (Current.is(Keywords.kw_instanceof)) {
836 Current.Type = TT_BinaryOperator;
837 } else if (isStartOfName(Current) &&
838 (!Line.MightBeFunctionDecl || Current.NestingLevel != 0)) {
839 Contexts.back().FirstStartOfName = &Current;
840 Current.Type = TT_StartOfName;
841 } else if (Current.is(tok::kw_auto)) {
842 AutoFound = true;
843 } else if (Current.is(tok::arrow) &&
844 Style.Language == FormatStyle::LK_Java) {
845 Current.Type = TT_LambdaArrow;
846 } else if (Current.is(tok::arrow) && AutoFound && Line.MustBeDeclaration &&
847 Current.NestingLevel == 0) {
848 Current.Type = TT_TrailingReturnArrow;
849 } else if (Current.isOneOf(tok::star, tok::amp, tok::ampamp)) {
850 Current.Type =
851 determineStarAmpUsage(Current, Contexts.back().CanBeExpression &&
852 Contexts.back().IsExpression,
853 Contexts.back().InTemplateArgument);
854 } else if (Current.isOneOf(tok::minus, tok::plus, tok::caret)) {
855 Current.Type = determinePlusMinusCaretUsage(Current);
856 if (Current.is(TT_UnaryOperator) && Current.is(tok::caret))
857 Contexts.back().CaretFound = true;
858 } else if (Current.isOneOf(tok::minusminus, tok::plusplus)) {
859 Current.Type = determineIncrementUsage(Current);
860 } else if (Current.isOneOf(tok::exclaim, tok::tilde)) {
861 Current.Type = TT_UnaryOperator;
862 } else if (Current.is(tok::question)) {
863 Current.Type = TT_ConditionalExpr;
864 } else if (Current.isBinaryOperator() &&
865 (!Current.Previous || Current.Previous->isNot(tok::l_square))) {
866 Current.Type = TT_BinaryOperator;
867 } else if (Current.is(tok::comment)) {
Daniel Jasper9b79efb2015-01-19 11:49:32 +0000868 Current.Type =
869 Current.TokenText.startswith("/*") ? TT_BlockComment : TT_LineComment;
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000870 } else if (Current.is(tok::r_paren)) {
871 if (rParenEndsCast(Current))
872 Current.Type = TT_CastRParen;
873 } else if (Current.is(tok::at) && Current.Next) {
874 switch (Current.Next->Tok.getObjCKeywordID()) {
875 case tok::objc_interface:
876 case tok::objc_implementation:
877 case tok::objc_protocol:
878 Current.Type = TT_ObjCDecl;
879 break;
880 case tok::objc_property:
881 Current.Type = TT_ObjCProperty;
882 break;
883 default:
884 break;
Aaron Ballman484ee9b2014-11-24 15:42:34 +0000885 }
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000886 } else if (Current.is(tok::period)) {
887 FormatToken *PreviousNoComment = Current.getPreviousNonComment();
888 if (PreviousNoComment &&
889 PreviousNoComment->isOneOf(tok::comma, tok::l_brace))
890 Current.Type = TT_DesignatedInitializerPeriod;
Nico Weberbeb03932015-01-09 23:25:06 +0000891 else if (Style.Language == FormatStyle::LK_Java && Current.Previous &&
892 Current.Previous->isOneOf(TT_JavaAnnotation,
893 TT_LeadingJavaAnnotation)) {
894 Current.Type = Current.Previous->Type;
895 }
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000896 } else if (Current.isOneOf(tok::identifier, tok::kw_const) &&
897 Current.Previous &&
898 !Current.Previous->isOneOf(tok::equal, tok::at) &&
899 Line.MightBeFunctionDecl && Contexts.size() == 1) {
900 // Line.MightBeFunctionDecl can only be true after the parentheses of a
901 // function declaration have been found.
902 Current.Type = TT_TrailingAnnotation;
Daniel Jasper3c42dba2015-02-18 17:17:15 +0000903 } else if ((Style.Language == FormatStyle::LK_Java ||
904 Style.Language == FormatStyle::LK_JavaScript) &&
905 Current.Previous) {
Nico Weberbeb03932015-01-09 23:25:06 +0000906 if (Current.Previous->is(tok::at) &&
907 Current.isNot(Keywords.kw_interface)) {
908 const FormatToken &AtToken = *Current.Previous;
909 const FormatToken *Previous = AtToken.getPreviousNonComment();
910 if (!Previous || Previous->is(TT_LeadingJavaAnnotation))
911 Current.Type = TT_LeadingJavaAnnotation;
912 else
913 Current.Type = TT_JavaAnnotation;
914 } else if (Current.Previous->is(tok::period) &&
915 Current.Previous->isOneOf(TT_JavaAnnotation,
916 TT_LeadingJavaAnnotation)) {
917 Current.Type = Current.Previous->Type;
918 }
Daniel Jasper3a9370c2013-02-04 07:21:18 +0000919 }
920 }
921
Daniel Jasperdba1c552013-07-02 09:47:29 +0000922 /// \brief Take a guess at whether \p Tok starts a name of a function or
923 /// variable declaration.
924 ///
925 /// This is a heuristic based on whether \p Tok is an identifier following
926 /// something that is likely a type.
927 bool isStartOfName(const FormatToken &Tok) {
Craig Topper2145bc02014-05-09 08:15:10 +0000928 if (Tok.isNot(tok::identifier) || !Tok.Previous)
Daniel Jasperdba1c552013-07-02 09:47:29 +0000929 return false;
930
Daniel Jasper404658a2015-01-14 10:00:20 +0000931 if (Tok.Previous->is(TT_LeadingJavaAnnotation))
Jacques Pienaarfc275112015-02-18 23:48:37 +0000932 return false;
Daniel Jasper404658a2015-01-14 10:00:20 +0000933
Daniel Jasperdba1c552013-07-02 09:47:29 +0000934 // Skip "const" as it does not have an influence on whether this is a name.
935 FormatToken *PreviousNotConst = Tok.Previous;
Craig Topper2145bc02014-05-09 08:15:10 +0000936 while (PreviousNotConst && PreviousNotConst->is(tok::kw_const))
Daniel Jasperdba1c552013-07-02 09:47:29 +0000937 PreviousNotConst = PreviousNotConst->Previous;
938
Craig Topper2145bc02014-05-09 08:15:10 +0000939 if (!PreviousNotConst)
Daniel Jasperdba1c552013-07-02 09:47:29 +0000940 return false;
941
Daniel Jasper3ac9b9e2013-07-08 14:34:09 +0000942 bool IsPPKeyword = PreviousNotConst->is(tok::identifier) &&
943 PreviousNotConst->Previous &&
944 PreviousNotConst->Previous->is(tok::hash);
Daniel Jasperdba1c552013-07-02 09:47:29 +0000945
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000946 if (PreviousNotConst->is(TT_TemplateCloser))
Daniel Jasper53643062013-08-19 10:16:18 +0000947 return PreviousNotConst && PreviousNotConst->MatchingParen &&
948 PreviousNotConst->MatchingParen->Previous &&
Daniel Jaspercaf86852014-11-20 09:48:11 +0000949 PreviousNotConst->MatchingParen->Previous->isNot(tok::period) &&
Daniel Jasper53643062013-08-19 10:16:18 +0000950 PreviousNotConst->MatchingParen->Previous->isNot(tok::kw_template);
951
Daniel Jasperf10a28d2014-05-05 13:48:09 +0000952 if (PreviousNotConst->is(tok::r_paren) && PreviousNotConst->MatchingParen &&
953 PreviousNotConst->MatchingParen->Previous &&
954 PreviousNotConst->MatchingParen->Previous->is(tok::kw_decltype))
955 return true;
956
Daniel Jasperdba1c552013-07-02 09:47:29 +0000957 return (!IsPPKeyword && PreviousNotConst->is(tok::identifier)) ||
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000958 PreviousNotConst->is(TT_PointerOrReference) ||
Daniel Jaspercb51cf42014-01-16 09:11:55 +0000959 PreviousNotConst->isSimpleTypeSpecifier();
Daniel Jasperdba1c552013-07-02 09:47:29 +0000960 }
961
Dinesh Dwivedi13b9b7e2014-05-06 09:08:34 +0000962 /// \brief Determine whether ')' is ending a cast.
963 bool rParenEndsCast(const FormatToken &Tok) {
Craig Topper4b566922014-06-09 02:04:02 +0000964 FormatToken *LeftOfParens = nullptr;
Dinesh Dwivedi13b9b7e2014-05-06 09:08:34 +0000965 if (Tok.MatchingParen)
966 LeftOfParens = Tok.MatchingParen->getPreviousNonComment();
Daniel Jasper4b3ba212014-08-25 09:36:07 +0000967 if (LeftOfParens && LeftOfParens->is(tok::r_paren) &&
968 LeftOfParens->MatchingParen)
969 LeftOfParens = LeftOfParens->MatchingParen->Previous;
Daniel Jasper8b76d602014-07-28 12:08:06 +0000970 if (LeftOfParens && LeftOfParens->is(tok::r_square) &&
971 LeftOfParens->MatchingParen &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000972 LeftOfParens->MatchingParen->is(TT_LambdaLSquare))
Daniel Jasper8b76d602014-07-28 12:08:06 +0000973 return false;
Daniel Jasper4f56b0b2014-11-26 12:23:10 +0000974 if (Tok.Next) {
Daniel Jasper77ef2be2015-01-05 10:33:39 +0000975 if (Tok.Next->is(tok::question))
976 return false;
Daniel Jasper4f56b0b2014-11-26 12:23:10 +0000977 if (Style.Language == FormatStyle::LK_JavaScript &&
978 Tok.Next->is(Keywords.kw_in))
979 return false;
980 if (Style.Language == FormatStyle::LK_Java && Tok.Next->is(tok::l_paren))
981 return true;
982 }
Dinesh Dwivedi13b9b7e2014-05-06 09:08:34 +0000983 bool IsCast = false;
984 bool ParensAreEmpty = Tok.Previous == Tok.MatchingParen;
Daniel Jaspera98b7b02014-11-25 10:05:17 +0000985 bool ParensAreType =
986 !Tok.Previous ||
987 Tok.Previous->isOneOf(TT_PointerOrReference, TT_TemplateCloser) ||
988 Tok.Previous->isSimpleTypeSpecifier();
Dinesh Dwivedi13b9b7e2014-05-06 09:08:34 +0000989 bool ParensCouldEndDecl =
990 Tok.Next && Tok.Next->isOneOf(tok::equal, tok::semi, tok::l_brace);
991 bool IsSizeOfOrAlignOf =
992 LeftOfParens && LeftOfParens->isOneOf(tok::kw_sizeof, tok::kw_alignof);
993 if (ParensAreType && !ParensCouldEndDecl && !IsSizeOfOrAlignOf &&
Daniel Jasper1c220482015-02-25 10:30:06 +0000994 (Contexts.size() > 1 && Contexts[Contexts.size() - 2].IsExpression))
Dinesh Dwivedi13b9b7e2014-05-06 09:08:34 +0000995 IsCast = true;
996 else if (Tok.Next && Tok.Next->isNot(tok::string_literal) &&
997 (Tok.Next->Tok.isLiteral() ||
998 Tok.Next->isOneOf(tok::kw_sizeof, tok::kw_alignof)))
999 IsCast = true;
1000 // If there is an identifier after the (), it is likely a cast, unless
1001 // there is also an identifier before the ().
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001002 else if (LeftOfParens && Tok.Next &&
Craig Topper4b566922014-06-09 02:04:02 +00001003 (LeftOfParens->Tok.getIdentifierInfo() == nullptr ||
1004 LeftOfParens->is(tok::kw_return)) &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001005 !LeftOfParens->isOneOf(TT_OverloadedOperator, tok::at,
1006 TT_TemplateCloser)) {
Dinesh Dwivedi13b9b7e2014-05-06 09:08:34 +00001007 if (Tok.Next->isOneOf(tok::identifier, tok::numeric_constant)) {
1008 IsCast = true;
1009 } else {
1010 // Use heuristics to recognize c style casting.
1011 FormatToken *Prev = Tok.Previous;
1012 if (Prev && Prev->isOneOf(tok::amp, tok::star))
1013 Prev = Prev->Previous;
1014
1015 if (Prev && Tok.Next && Tok.Next->Next) {
1016 bool NextIsUnary = Tok.Next->isUnaryOperator() ||
1017 Tok.Next->isOneOf(tok::amp, tok::star);
Daniel Jaspera45eb4c2014-10-06 13:16:43 +00001018 IsCast =
1019 NextIsUnary && !Tok.Next->is(tok::plus) &&
1020 Tok.Next->Next->isOneOf(tok::identifier, tok::numeric_constant);
Dinesh Dwivedi13b9b7e2014-05-06 09:08:34 +00001021 }
1022
1023 for (; Prev != Tok.MatchingParen; Prev = Prev->Previous) {
1024 if (!Prev || !Prev->isOneOf(tok::kw_const, tok::identifier)) {
1025 IsCast = false;
1026 break;
1027 }
1028 }
1029 }
1030 }
1031 return IsCast && !ParensAreEmpty;
1032 }
1033
Daniel Jasper3a9370c2013-02-04 07:21:18 +00001034 /// \brief Return the type of the given token assuming it is * or &.
Manuel Klimekf81e5c02014-03-27 11:17:36 +00001035 TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression,
1036 bool InTemplateArgument) {
Daniel Jasper3a038de2014-09-05 08:53:45 +00001037 if (Style.Language == FormatStyle::LK_JavaScript)
1038 return TT_BinaryOperator;
1039
Alexander Kornienko1efe0a02013-07-04 14:47:51 +00001040 const FormatToken *PrevToken = Tok.getPreviousNonComment();
Craig Topper2145bc02014-05-09 08:15:10 +00001041 if (!PrevToken)
Daniel Jasper3a9370c2013-02-04 07:21:18 +00001042 return TT_UnaryOperator;
1043
Alexander Kornienko1efe0a02013-07-04 14:47:51 +00001044 const FormatToken *NextToken = Tok.getNextNonComment();
Daniel Jasperbcb55ee2014-11-21 14:08:38 +00001045 if (!NextToken ||
1046 (NextToken->is(tok::l_brace) && !NextToken->getNextNonComment()))
Daniel Jasper3a9370c2013-02-04 07:21:18 +00001047 return TT_Unknown;
1048
Daniel Jasper73e171f2014-08-29 12:54:38 +00001049 if (PrevToken->is(tok::coloncolon))
Daniel Jasper8eb371b2013-03-01 17:13:29 +00001050 return TT_PointerOrReference;
1051
Alexander Kornienko62b85b92013-03-13 14:41:29 +00001052 if (PrevToken->isOneOf(tok::l_paren, tok::l_square, tok::l_brace,
Daniel Jasperae907642013-03-14 10:50:25 +00001053 tok::comma, tok::semi, tok::kw_return, tok::colon,
Aaron Ballman484ee9b2014-11-24 15:42:34 +00001054 tok::equal, tok::kw_delete, tok::kw_sizeof) ||
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001055 PrevToken->isOneOf(TT_BinaryOperator, TT_ConditionalExpr,
1056 TT_UnaryOperator, TT_CastRParen))
Daniel Jasper3a9370c2013-02-04 07:21:18 +00001057 return TT_UnaryOperator;
1058
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001059 if (NextToken->is(tok::l_square) && NextToken->isNot(TT_LambdaLSquare))
Nico Weber5d2624e2013-02-06 06:20:11 +00001060 return TT_PointerOrReference;
Daniel Jasper1c220482015-02-25 10:30:06 +00001061 if (NextToken->isOneOf(tok::kw_operator, tok::comma, tok::semi))
Daniel Jasper32ccb032014-06-23 07:36:18 +00001062 return TT_PointerOrReference;
Nico Weber5d2624e2013-02-06 06:20:11 +00001063
Daniel Jasper71665cd2013-09-10 10:26:38 +00001064 if (PrevToken->is(tok::r_paren) && PrevToken->MatchingParen &&
1065 PrevToken->MatchingParen->Previous &&
Daniel Jasper4ac7de72014-06-11 07:35:16 +00001066 PrevToken->MatchingParen->Previous->isOneOf(tok::kw_typeof,
1067 tok::kw_decltype))
Daniel Jasper71665cd2013-09-10 10:26:38 +00001068 return TT_PointerOrReference;
1069
Manuel Klimek94815562014-03-28 09:27:09 +00001070 if (PrevToken->Tok.isLiteral() ||
1071 PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::kw_true,
Daniel Jasperf0c809a2014-10-28 18:28:22 +00001072 tok::kw_false, tok::r_brace) ||
Manuel Klimek94815562014-03-28 09:27:09 +00001073 NextToken->Tok.isLiteral() ||
1074 NextToken->isOneOf(tok::kw_true, tok::kw_false) ||
1075 NextToken->isUnaryOperator() ||
Manuel Klimekf81e5c02014-03-27 11:17:36 +00001076 // If we know we're in a template argument, there are no named
1077 // declarations. Thus, having an identifier on the right-hand side
1078 // indicates a binary operator.
1079 (InTemplateArgument && NextToken->Tok.isAnyIdentifier()))
Daniel Jasper3a9370c2013-02-04 07:21:18 +00001080 return TT_BinaryOperator;
1081
Daniel Jasper13a7f462014-10-28 18:11:52 +00001082 // "&&(" is quite unlikely to be two successive unary "&".
1083 if (Tok.is(tok::ampamp) && NextToken && NextToken->is(tok::l_paren))
1084 return TT_BinaryOperator;
1085
Daniel Jasper7d028292014-06-02 11:54:20 +00001086 // This catches some cases where evaluation order is used as control flow:
1087 // aaa && aaa->f();
1088 const FormatToken *NextNextToken = NextToken->getNextNonComment();
1089 if (NextNextToken && NextNextToken->is(tok::arrow))
1090 return TT_BinaryOperator;
1091
Daniel Jasper3a9370c2013-02-04 07:21:18 +00001092 // It is very unlikely that we are going to find a pointer or reference type
1093 // definition on the RHS of an assignment.
Daniel Jasperbb86d842014-11-23 19:15:35 +00001094 if (IsExpression && !Contexts.back().CaretFound)
Daniel Jasper3a9370c2013-02-04 07:21:18 +00001095 return TT_BinaryOperator;
1096
1097 return TT_PointerOrReference;
1098 }
1099
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001100 TokenType determinePlusMinusCaretUsage(const FormatToken &Tok) {
Alexander Kornienko1efe0a02013-07-04 14:47:51 +00001101 const FormatToken *PrevToken = Tok.getPreviousNonComment();
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001102 if (!PrevToken || PrevToken->is(TT_CastRParen))
Daniel Jasper3a9370c2013-02-04 07:21:18 +00001103 return TT_UnaryOperator;
1104
1105 // Use heuristics to recognize unary operators.
Alexander Kornienko62b85b92013-03-13 14:41:29 +00001106 if (PrevToken->isOneOf(tok::equal, tok::l_paren, tok::comma, tok::l_square,
1107 tok::question, tok::colon, tok::kw_return,
1108 tok::kw_case, tok::at, tok::l_brace))
Daniel Jasper3a9370c2013-02-04 07:21:18 +00001109 return TT_UnaryOperator;
1110
Nico Weberb76de882013-02-05 16:21:00 +00001111 // There can't be two consecutive binary operators.
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001112 if (PrevToken->is(TT_BinaryOperator))
Daniel Jasper3a9370c2013-02-04 07:21:18 +00001113 return TT_UnaryOperator;
1114
1115 // Fall back to marking the token as binary operator.
1116 return TT_BinaryOperator;
1117 }
1118
1119 /// \brief Determine whether ++/-- are pre- or post-increments/-decrements.
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001120 TokenType determineIncrementUsage(const FormatToken &Tok) {
Alexander Kornienko1efe0a02013-07-04 14:47:51 +00001121 const FormatToken *PrevToken = Tok.getPreviousNonComment();
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001122 if (!PrevToken || PrevToken->is(TT_CastRParen))
Daniel Jasper3a9370c2013-02-04 07:21:18 +00001123 return TT_UnaryOperator;
Alexander Kornienko62b85b92013-03-13 14:41:29 +00001124 if (PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::identifier))
Daniel Jasper3a9370c2013-02-04 07:21:18 +00001125 return TT_TrailingUnaryOperator;
1126
1127 return TT_UnaryOperator;
1128 }
Daniel Jasperc697ad22013-02-06 10:05:46 +00001129
1130 SmallVector<Context, 8> Contexts;
1131
Daniel Jasper8de9ed02013-08-22 15:00:41 +00001132 const FormatStyle &Style;
Daniel Jasperc697ad22013-02-06 10:05:46 +00001133 AnnotatedLine &Line;
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001134 FormatToken *CurrentToken;
Daniel Jasper6cdec7c2013-07-09 14:36:48 +00001135 bool AutoFound;
Daniel Jasperd0ec0d62014-11-04 12:41:02 +00001136 const AdditionalKeywords &Keywords;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001137};
1138
Benjamin Kramer28b45ce2015-03-08 16:06:46 +00001139static const int PrecedenceUnaryOperator = prec::PointerToMember + 1;
1140static const int PrecedenceArrowAndPeriod = prec::PointerToMember + 2;
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001141
Daniel Jasper400adc62013-02-08 15:28:42 +00001142/// \brief Parses binary expressions by inserting fake parenthesis based on
1143/// operator precedence.
1144class ExpressionParser {
1145public:
Daniel Jasperd0ec0d62014-11-04 12:41:02 +00001146 ExpressionParser(const FormatStyle &Style, const AdditionalKeywords &Keywords,
1147 AnnotatedLine &Line)
1148 : Style(Style), Keywords(Keywords), Current(Line.First) {}
Daniel Jasper400adc62013-02-08 15:28:42 +00001149
1150 /// \brief Parse expressions with the given operatore precedence.
Daniel Jaspercd8599e2013-02-23 21:01:55 +00001151 void parse(int Precedence = 0) {
Daniel Jasperf48b5ab2013-11-07 19:23:49 +00001152 // Skip 'return' and ObjC selector colons as they are not part of a binary
1153 // expression.
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001154 while (Current && (Current->is(tok::kw_return) ||
1155 (Current->is(tok::colon) &&
1156 Current->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral))))
Daniel Jaspereabede62013-09-30 08:29:03 +00001157 next();
1158
Craig Topper2145bc02014-05-09 08:15:10 +00001159 if (!Current || Precedence > PrecedenceArrowAndPeriod)
Daniel Jasper0649d362013-08-23 15:14:03 +00001160 return;
1161
Daniel Jasper2c611c02013-05-31 14:56:12 +00001162 // Conditional expressions need to be parsed separately for proper nesting.
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001163 if (Precedence == prec::Conditional) {
Daniel Jasper2c611c02013-05-31 14:56:12 +00001164 parseConditionalExpr();
1165 return;
1166 }
Daniel Jasper0649d362013-08-23 15:14:03 +00001167
1168 // Parse unary operators, which all have a higher precedence than binary
1169 // operators.
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001170 if (Precedence == PrecedenceUnaryOperator) {
Daniel Jasper0649d362013-08-23 15:14:03 +00001171 parseUnaryOperator();
Daniel Jasper400adc62013-02-08 15:28:42 +00001172 return;
Daniel Jasper0649d362013-08-23 15:14:03 +00001173 }
Daniel Jasper400adc62013-02-08 15:28:42 +00001174
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001175 FormatToken *Start = Current;
Craig Topper2145bc02014-05-09 08:15:10 +00001176 FormatToken *LatestOperator = nullptr;
Daniel Jasper0e617842014-04-16 12:26:54 +00001177 unsigned OperatorIndex = 0;
Daniel Jasper400adc62013-02-08 15:28:42 +00001178
Daniel Jaspercd8599e2013-02-23 21:01:55 +00001179 while (Current) {
Daniel Jasper400adc62013-02-08 15:28:42 +00001180 // Consume operators with higher precedence.
Daniel Jasper6bee6822013-04-08 20:33:42 +00001181 parse(Precedence + 1);
Daniel Jasper400adc62013-02-08 15:28:42 +00001182
Daniel Jasper0649d362013-08-23 15:14:03 +00001183 int CurrentPrecedence = getCurrentPrecedence();
1184
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001185 if (Current && Current->is(TT_SelectorName) &&
Daniel Jasperb88b25f2013-12-23 07:29:06 +00001186 Precedence == CurrentPrecedence) {
1187 if (LatestOperator)
1188 addFakeParenthesis(Start, prec::Level(Precedence));
Daniel Jasper0649d362013-08-23 15:14:03 +00001189 Start = Current;
Daniel Jasperb88b25f2013-12-23 07:29:06 +00001190 }
Daniel Jaspercd8599e2013-02-23 21:01:55 +00001191
Daniel Jasper400adc62013-02-08 15:28:42 +00001192 // At the end of the line or when an operator with higher precedence is
1193 // found, insert fake parenthesis and return.
Daniel Jasper86296e32014-10-20 11:12:51 +00001194 if (!Current || (Current->closesScope() && Current->MatchingParen) ||
Daniel Jasper6c22c442014-11-14 13:03:40 +00001195 (CurrentPrecedence != -1 && CurrentPrecedence < Precedence) ||
1196 (CurrentPrecedence == prec::Conditional &&
1197 Precedence == prec::Assignment && Current->is(tok::colon))) {
Daniel Jasper83791072014-12-03 13:20:49 +00001198 break;
Daniel Jasper400adc62013-02-08 15:28:42 +00001199 }
1200
1201 // Consume scopes: (), [], <> and {}
Daniel Jasperc04baae2013-04-10 09:49:49 +00001202 if (Current->opensScope()) {
1203 while (Current && !Current->closesScope()) {
Daniel Jasper400adc62013-02-08 15:28:42 +00001204 next();
1205 parse();
1206 }
1207 next();
1208 } else {
1209 // Operator found.
Daniel Jasper0e617842014-04-16 12:26:54 +00001210 if (CurrentPrecedence == Precedence) {
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001211 LatestOperator = Current;
Daniel Jasper0e617842014-04-16 12:26:54 +00001212 Current->OperatorIndex = OperatorIndex;
1213 ++OperatorIndex;
1214 }
Daniel Jasper3eb341c2014-11-11 23:04:51 +00001215 next(/*SkipPastLeadingComments=*/Precedence > 0);
Daniel Jasper400adc62013-02-08 15:28:42 +00001216 }
1217 }
Daniel Jasper83791072014-12-03 13:20:49 +00001218
1219 if (LatestOperator && (Current || Precedence > 0)) {
1220 LatestOperator->LastOperator = true;
1221 if (Precedence == PrecedenceArrowAndPeriod) {
1222 // Call expressions don't have a binary operator precedence.
1223 addFakeParenthesis(Start, prec::Unknown);
1224 } else {
1225 addFakeParenthesis(Start, prec::Level(Precedence));
1226 }
1227 }
Daniel Jasper400adc62013-02-08 15:28:42 +00001228 }
1229
1230private:
Daniel Jasper0649d362013-08-23 15:14:03 +00001231 /// \brief Gets the precedence (+1) of the given token for binary operators
1232 /// and other tokens that we treat like binary operators.
1233 int getCurrentPrecedence() {
1234 if (Current) {
Daniel Jasper97bfb7b2014-09-05 08:29:31 +00001235 const FormatToken *NextNonComment = Current->getNextNonComment();
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001236 if (Current->is(TT_ConditionalExpr))
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001237 return prec::Conditional;
Daniel Jasper97bfb7b2014-09-05 08:29:31 +00001238 else if (NextNonComment && NextNonComment->is(tok::colon) &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001239 NextNonComment->is(TT_DictLiteral))
Daniel Jasper97bfb7b2014-09-05 08:29:31 +00001240 return prec::Comma;
Daniel Jasper8354ea82014-11-21 12:14:12 +00001241 else if (Current->is(TT_LambdaArrow))
1242 return prec::Comma;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001243 else if (Current->isOneOf(tok::semi, TT_InlineASMColon,
1244 TT_SelectorName) ||
Daniel Jasper97bfb7b2014-09-05 08:29:31 +00001245 (Current->is(tok::comment) && NextNonComment &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001246 NextNonComment->is(TT_SelectorName)))
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001247 return 0;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001248 else if (Current->is(TT_RangeBasedForLoopColon))
Daniel Jasper9cc3e972014-02-07 10:09:46 +00001249 return prec::Comma;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001250 else if (Current->is(TT_BinaryOperator) || Current->is(tok::comma))
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001251 return Current->getPrecedence();
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001252 else if (Current->isOneOf(tok::period, tok::arrow))
1253 return PrecedenceArrowAndPeriod;
Daniel Jasper50b4bd72014-11-02 19:16:41 +00001254 else if (Style.Language == FormatStyle::LK_Java &&
Daniel Jasper375815d2014-11-26 12:31:19 +00001255 Current->isOneOf(Keywords.kw_extends, Keywords.kw_implements,
1256 Keywords.kw_throws))
Daniel Jasper50b4bd72014-11-02 19:16:41 +00001257 return 0;
Daniel Jasper0649d362013-08-23 15:14:03 +00001258 }
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001259 return -1;
Daniel Jasper0649d362013-08-23 15:14:03 +00001260 }
1261
Daniel Jasper2c611c02013-05-31 14:56:12 +00001262 void addFakeParenthesis(FormatToken *Start, prec::Level Precedence) {
1263 Start->FakeLParens.push_back(Precedence);
Daniel Jasper562ecd42013-09-06 08:08:14 +00001264 if (Precedence > prec::Unknown)
1265 Start->StartsBinaryExpression = true;
1266 if (Current) {
Daniel Jasper119ff532014-11-14 12:31:14 +00001267 FormatToken *Previous = Current->Previous;
Daniel Jasperc0956632014-12-03 14:02:59 +00001268 while (Previous->is(tok::comment) && Previous->Previous)
Daniel Jasper119ff532014-11-14 12:31:14 +00001269 Previous = Previous->Previous;
1270 ++Previous->FakeRParens;
Daniel Jasper562ecd42013-09-06 08:08:14 +00001271 if (Precedence > prec::Unknown)
Daniel Jasper119ff532014-11-14 12:31:14 +00001272 Previous->EndsBinaryExpression = true;
Daniel Jasper562ecd42013-09-06 08:08:14 +00001273 }
Daniel Jasper2c611c02013-05-31 14:56:12 +00001274 }
1275
Daniel Jasper0649d362013-08-23 15:14:03 +00001276 /// \brief Parse unary operator expressions and surround them with fake
1277 /// parentheses if appropriate.
1278 void parseUnaryOperator() {
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001279 if (!Current || Current->isNot(TT_UnaryOperator)) {
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001280 parse(PrecedenceArrowAndPeriod);
Daniel Jasper0649d362013-08-23 15:14:03 +00001281 return;
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001282 }
Daniel Jasper0649d362013-08-23 15:14:03 +00001283
1284 FormatToken *Start = Current;
1285 next();
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001286 parseUnaryOperator();
Daniel Jasper0649d362013-08-23 15:14:03 +00001287
Daniel Jasper0649d362013-08-23 15:14:03 +00001288 // The actual precedence doesn't matter.
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001289 addFakeParenthesis(Start, prec::Unknown);
Daniel Jasper0649d362013-08-23 15:14:03 +00001290 }
1291
Daniel Jasper2c611c02013-05-31 14:56:12 +00001292 void parseConditionalExpr() {
Daniel Jasper1a31bab2014-10-16 09:10:11 +00001293 while (Current && Current->isTrailingComment()) {
1294 next();
1295 }
Daniel Jasper2c611c02013-05-31 14:56:12 +00001296 FormatToken *Start = Current;
Daniel Jasperb27c4b72013-08-27 11:09:05 +00001297 parse(prec::LogicalOr);
Daniel Jasper2c611c02013-05-31 14:56:12 +00001298 if (!Current || !Current->is(tok::question))
1299 return;
1300 next();
Daniel Jasper6c22c442014-11-14 13:03:40 +00001301 parse(prec::Assignment);
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001302 if (!Current || Current->isNot(TT_ConditionalExpr))
Daniel Jasper2c611c02013-05-31 14:56:12 +00001303 return;
1304 next();
Daniel Jasper6c22c442014-11-14 13:03:40 +00001305 parse(prec::Assignment);
Daniel Jasper2c611c02013-05-31 14:56:12 +00001306 addFakeParenthesis(Start, prec::Conditional);
1307 }
1308
Daniel Jasper94e11d02014-09-04 14:58:30 +00001309 void next(bool SkipPastLeadingComments = true) {
Alexander Kornienkoafaa8f52013-06-17 13:19:53 +00001310 if (Current)
1311 Current = Current->Next;
Daniel Jasper94e11d02014-09-04 14:58:30 +00001312 while (Current &&
1313 (Current->NewlinesBefore == 0 || SkipPastLeadingComments) &&
1314 Current->isTrailingComment())
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001315 Current = Current->Next;
Daniel Jasper400adc62013-02-08 15:28:42 +00001316 }
1317
Daniel Jasper50b4bd72014-11-02 19:16:41 +00001318 const FormatStyle &Style;
Daniel Jasperd0ec0d62014-11-04 12:41:02 +00001319 const AdditionalKeywords &Keywords;
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001320 FormatToken *Current;
Daniel Jasper400adc62013-02-08 15:28:42 +00001321};
1322
Craig Topper318ed7c2013-07-01 04:03:19 +00001323} // end anonymous namespace
1324
Nico Weberbeb03932015-01-09 23:25:06 +00001325void TokenAnnotator::setCommentLineLevels(
1326 SmallVectorImpl<AnnotatedLine *> &Lines) {
Craig Topper2145bc02014-05-09 08:15:10 +00001327 const AnnotatedLine *NextNonCommentLine = nullptr;
Daniel Jasperbbf5c1c2013-11-05 19:10:03 +00001328 for (SmallVectorImpl<AnnotatedLine *>::reverse_iterator I = Lines.rbegin(),
1329 E = Lines.rend();
1330 I != E; ++I) {
1331 if (NextNonCommentLine && (*I)->First->is(tok::comment) &&
Craig Topper2145bc02014-05-09 08:15:10 +00001332 (*I)->First->Next == nullptr)
Daniel Jasperbbf5c1c2013-11-05 19:10:03 +00001333 (*I)->Level = NextNonCommentLine->Level;
Daniel Jasper1c5d9df2013-09-06 07:54:20 +00001334 else
Craig Topper2145bc02014-05-09 08:15:10 +00001335 NextNonCommentLine = (*I)->First->isNot(tok::r_brace) ? (*I) : nullptr;
Daniel Jasperbbf5c1c2013-11-05 19:10:03 +00001336
1337 setCommentLineLevels((*I)->Children);
Daniel Jasper1c5d9df2013-09-06 07:54:20 +00001338 }
1339}
1340
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001341void TokenAnnotator::annotate(AnnotatedLine &Line) {
Daniel Jasper1c5d9df2013-09-06 07:54:20 +00001342 for (SmallVectorImpl<AnnotatedLine *>::iterator I = Line.Children.begin(),
1343 E = Line.Children.end();
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00001344 I != E; ++I) {
1345 annotate(**I);
1346 }
Daniel Jasperd0ec0d62014-11-04 12:41:02 +00001347 AnnotatingParser Parser(Style, Line, Keywords);
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001348 Line.Type = Parser.parseLine();
1349 if (Line.Type == LT_Invalid)
1350 return;
1351
Daniel Jasperd0ec0d62014-11-04 12:41:02 +00001352 ExpressionParser ExprParser(Style, Keywords, Line);
Daniel Jasper400adc62013-02-08 15:28:42 +00001353 ExprParser.parse();
1354
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001355 if (Line.First->is(TT_ObjCMethodSpecifier))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001356 Line.Type = LT_ObjCMethodDecl;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001357 else if (Line.First->is(TT_ObjCDecl))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001358 Line.Type = LT_ObjCDecl;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001359 else if (Line.First->is(TT_ObjCProperty))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001360 Line.Type = LT_ObjCProperty;
1361
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001362 Line.First->SpacesRequiredBefore = 1;
1363 Line.First->CanBreakBefore = Line.First->MustBreakBefore;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001364}
1365
Daniel Jasper4355e7f2014-07-09 07:50:33 +00001366// This function heuristically determines whether 'Current' starts the name of a
1367// function declaration.
1368static bool isFunctionDeclarationName(const FormatToken &Current) {
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001369 if (!Current.is(TT_StartOfName) || Current.NestingLevel != 0)
Daniel Jasper4355e7f2014-07-09 07:50:33 +00001370 return false;
1371 const FormatToken *Next = Current.Next;
1372 for (; Next; Next = Next->Next) {
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001373 if (Next->is(TT_TemplateOpener)) {
Daniel Jasper4355e7f2014-07-09 07:50:33 +00001374 Next = Next->MatchingParen;
1375 } else if (Next->is(tok::coloncolon)) {
1376 Next = Next->Next;
1377 if (!Next || !Next->is(tok::identifier))
1378 return false;
1379 } else if (Next->is(tok::l_paren)) {
1380 break;
1381 } else {
1382 return false;
1383 }
1384 }
1385 if (!Next)
1386 return false;
1387 assert(Next->is(tok::l_paren));
1388 if (Next->Next == Next->MatchingParen)
1389 return true;
Daniel Jasper193cdd32015-01-19 10:52:16 +00001390 for (const FormatToken *Tok = Next->Next; Tok && Tok != Next->MatchingParen;
Daniel Jasper4355e7f2014-07-09 07:50:33 +00001391 Tok = Tok->Next) {
1392 if (Tok->is(tok::kw_const) || Tok->isSimpleTypeSpecifier() ||
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001393 Tok->isOneOf(TT_PointerOrReference, TT_StartOfName))
Daniel Jasper4355e7f2014-07-09 07:50:33 +00001394 return true;
1395 if (Tok->isOneOf(tok::l_brace, tok::string_literal) || Tok->Tok.isLiteral())
1396 return false;
1397 }
1398 return false;
1399}
1400
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001401void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) {
Daniel Jasper5f3ea472014-05-22 08:36:53 +00001402 for (SmallVectorImpl<AnnotatedLine *>::iterator I = Line.Children.begin(),
1403 E = Line.Children.end();
1404 I != E; ++I) {
1405 calculateFormattingInformation(**I);
1406 }
1407
Alexander Kornienko39856b72013-09-10 09:38:25 +00001408 Line.First->TotalLength =
1409 Line.First->IsMultiline ? Style.ColumnLimit : Line.First->ColumnWidth;
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001410 if (!Line.First->Next)
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001411 return;
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001412 FormatToken *Current = Line.First->Next;
Daniel Jasper4fcc8b92013-11-07 17:52:51 +00001413 bool InFunctionDecl = Line.MightBeFunctionDecl;
Craig Topper2145bc02014-05-09 08:15:10 +00001414 while (Current) {
Daniel Jasper4355e7f2014-07-09 07:50:33 +00001415 if (isFunctionDeclarationName(*Current))
1416 Current->Type = TT_FunctionDeclarationName;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001417 if (Current->is(TT_LineComment)) {
Daniel Jasper84a12e12014-03-10 15:06:25 +00001418 if (Current->Previous->BlockKind == BK_BracedInit &&
1419 Current->Previous->opensScope())
Daniel Jasper5a611392013-12-19 21:41:37 +00001420 Current->SpacesRequiredBefore = Style.Cpp11BracedListStyle ? 0 : 1;
1421 else
1422 Current->SpacesRequiredBefore = Style.SpacesBeforeTrailingComments;
Daniel Jasper14e58e52014-03-21 11:58:45 +00001423
1424 // If we find a trailing comment, iterate backwards to determine whether
1425 // it seems to relate to a specific parameter. If so, break before that
1426 // parameter to avoid changing the comment's meaning. E.g. don't move 'b'
1427 // to the previous line in:
1428 // SomeFunction(a,
1429 // b, // comment
1430 // c);
Daniel Jasper28df0a32014-03-21 12:15:40 +00001431 if (!Current->HasUnescapedNewline) {
Daniel Jasper14e58e52014-03-21 11:58:45 +00001432 for (FormatToken *Parameter = Current->Previous; Parameter;
1433 Parameter = Parameter->Previous) {
1434 if (Parameter->isOneOf(tok::comment, tok::r_brace))
1435 break;
1436 if (Parameter->Previous && Parameter->Previous->is(tok::comma)) {
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001437 if (!Parameter->Previous->is(TT_CtorInitializerComma) &&
Daniel Jasper14e58e52014-03-21 11:58:45 +00001438 Parameter->HasUnescapedNewline)
1439 Parameter->MustBreakBefore = true;
1440 break;
1441 }
1442 }
1443 }
Daniel Jasperb88b25f2013-12-23 07:29:06 +00001444 } else if (Current->SpacesRequiredBefore == 0 &&
Daniel Jasper166c19b2014-05-06 14:12:21 +00001445 spaceRequiredBefore(Line, *Current)) {
Alexander Kornienko384b40b2013-10-11 21:43:05 +00001446 Current->SpacesRequiredBefore = 1;
Daniel Jasper5a611392013-12-19 21:41:37 +00001447 }
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001448
Daniel Jasperfb81b092013-09-17 09:52:48 +00001449 Current->MustBreakBefore =
1450 Current->MustBreakBefore || mustBreakBefore(Line, *Current);
1451
Nico Weberbeb03932015-01-09 23:25:06 +00001452 if (Style.AlwaysBreakAfterDefinitionReturnType && InFunctionDecl &&
1453 Current->is(TT_FunctionDeclarationName) &&
1454 !Line.Last->isOneOf(tok::semi, tok::comment)) // Only for definitions.
Daniel Jasperdb764792014-08-14 11:36:03 +00001455 // FIXME: Line.Last points to other characters than tok::semi
1456 // and tok::lbrace.
Daniel Jasperca4ea1c2014-08-05 12:16:31 +00001457 Current->MustBreakBefore = true;
1458
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001459 Current->CanBreakBefore =
1460 Current->MustBreakBefore || canBreakBefore(Line, *Current);
Daniel Jasper5f3ea472014-05-22 08:36:53 +00001461 unsigned ChildSize = 0;
1462 if (Current->Previous->Children.size() == 1) {
1463 FormatToken &LastOfChild = *Current->Previous->Children[0]->Last;
1464 ChildSize = LastOfChild.isTrailingComment() ? Style.ColumnLimit
1465 : LastOfChild.TotalLength + 1;
1466 }
Nico Weberbeb03932015-01-09 23:25:06 +00001467 const FormatToken *Prev = Current->Previous;
Daniel Jasper56346192014-10-27 16:31:46 +00001468 if (Current->MustBreakBefore || Prev->Children.size() > 1 ||
1469 (Prev->Children.size() == 1 &&
1470 Prev->Children[0]->First->MustBreakBefore) ||
Alexander Kornienko39856b72013-09-10 09:38:25 +00001471 Current->IsMultiline)
Daniel Jasper56346192014-10-27 16:31:46 +00001472 Current->TotalLength = Prev->TotalLength + Style.ColumnLimit;
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001473 else
Daniel Jasper56346192014-10-27 16:31:46 +00001474 Current->TotalLength = Prev->TotalLength + Current->ColumnWidth +
1475 ChildSize + Current->SpacesRequiredBefore;
Daniel Jasper4fcc8b92013-11-07 17:52:51 +00001476
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001477 if (Current->is(TT_CtorInitializerColon))
Daniel Jasper4fcc8b92013-11-07 17:52:51 +00001478 InFunctionDecl = false;
1479
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001480 // FIXME: Only calculate this if CanBreakBefore is true once static
1481 // initializers etc. are sorted out.
1482 // FIXME: Move magic numbers to a better place.
Daniel Jasper4fcc8b92013-11-07 17:52:51 +00001483 Current->SplitPenalty = 20 * Current->BindingStrength +
1484 splitPenalty(Line, *Current, InFunctionDecl);
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001485
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001486 Current = Current->Next;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001487 }
Daniel Jasper6bee6822013-04-08 20:33:42 +00001488
Manuel Klimek4fe43002013-05-22 12:51:29 +00001489 calculateUnbreakableTailLengths(Line);
Craig Topper2145bc02014-05-09 08:15:10 +00001490 for (Current = Line.First; Current != nullptr; Current = Current->Next) {
Daniel Jasper8de9ed02013-08-22 15:00:41 +00001491 if (Current->Role)
1492 Current->Role->precomputeFormattingInfos(Current);
1493 }
1494
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00001495 DEBUG({ printDebugInfo(Line); });
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001496}
1497
Manuel Klimek4fe43002013-05-22 12:51:29 +00001498void TokenAnnotator::calculateUnbreakableTailLengths(AnnotatedLine &Line) {
1499 unsigned UnbreakableTailLength = 0;
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001500 FormatToken *Current = Line.Last;
Craig Topper2145bc02014-05-09 08:15:10 +00001501 while (Current) {
Manuel Klimek4fe43002013-05-22 12:51:29 +00001502 Current->UnbreakableTailLength = UnbreakableTailLength;
1503 if (Current->CanBreakBefore ||
1504 Current->isOneOf(tok::comment, tok::string_literal)) {
1505 UnbreakableTailLength = 0;
1506 } else {
1507 UnbreakableTailLength +=
Alexander Kornienko39856b72013-09-10 09:38:25 +00001508 Current->ColumnWidth + Current->SpacesRequiredBefore;
Manuel Klimek4fe43002013-05-22 12:51:29 +00001509 }
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001510 Current = Current->Previous;
Manuel Klimek4fe43002013-05-22 12:51:29 +00001511 }
1512}
1513
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001514unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line,
Daniel Jasper4fcc8b92013-11-07 17:52:51 +00001515 const FormatToken &Tok,
1516 bool InFunctionDecl) {
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001517 const FormatToken &Left = *Tok.Previous;
1518 const FormatToken &Right = Tok;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001519
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001520 if (Left.is(tok::semi))
1521 return 0;
Daniel Jasper734d52b2014-11-14 10:15:56 +00001522
1523 if (Style.Language == FormatStyle::LK_Java) {
Daniel Jasper375815d2014-11-26 12:31:19 +00001524 if (Right.isOneOf(Keywords.kw_extends, Keywords.kw_throws))
Daniel Jasper734d52b2014-11-14 10:15:56 +00001525 return 1;
1526 if (Right.is(Keywords.kw_implements))
1527 return 2;
1528 if (Left.is(tok::comma) && Left.NestingLevel == 0)
1529 return 3;
Daniel Jasper41368e92014-11-27 15:37:42 +00001530 } else if (Style.Language == FormatStyle::LK_JavaScript) {
1531 if (Right.is(Keywords.kw_function))
1532 return 100;
Daniel Jasper734d52b2014-11-14 10:15:56 +00001533 }
1534
Daniel Jasper783bac62014-04-15 09:54:30 +00001535 if (Left.is(tok::comma) || (Right.is(tok::identifier) && Right.Next &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001536 Right.Next->is(TT_DictLiteral)))
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001537 return 1;
Daniel Jasper7052ce62014-01-19 09:04:08 +00001538 if (Right.is(tok::l_square)) {
1539 if (Style.Language == FormatStyle::LK_Proto)
1540 return 1;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001541 if (!Right.isOneOf(TT_ObjCMethodExpr, TT_LambdaLSquare))
Daniel Jasperecaba172014-06-10 13:27:57 +00001542 return 500;
Daniel Jasper7052ce62014-01-19 09:04:08 +00001543 }
Daniel Jasper734d52b2014-11-14 10:15:56 +00001544
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001545 if (Right.isOneOf(TT_StartOfName, TT_FunctionDeclarationName) ||
1546 Right.is(tok::kw_operator)) {
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001547 if (Line.First->is(tok::kw_for) && Right.PartOfMultiVariableDeclStmt)
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00001548 return 3;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001549 if (Left.is(TT_StartOfName))
Daniel Jasper40db06a2013-07-11 12:34:23 +00001550 return 20;
Daniel Jasper63af7c42013-12-09 14:40:19 +00001551 if (InFunctionDecl && Right.NestingLevel == 0)
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00001552 return Style.PenaltyReturnTypeOnItsOwnLine;
Daniel Jasper53643062013-08-19 10:16:18 +00001553 return 200;
Daniel Jasper26d1b1d2013-02-24 18:54:32 +00001554 }
Daniel Jasperb754a742015-03-12 15:04:53 +00001555 if (Right.is(TT_PointerOrReference))
Daniel Jasper414c9c62015-03-19 09:40:16 +00001556 return 190;
Daniel Jaspere6623162015-03-02 10:35:13 +00001557 if (Right.is(TT_TrailingReturnArrow))
1558 return 110;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001559 if (Left.is(tok::equal) && Right.is(tok::l_brace))
1560 return 150;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001561 if (Left.is(TT_CastRParen))
Daniel Jasper1bc1b502013-07-05 07:58:34 +00001562 return 100;
Daniel Jasper215d6c82014-01-22 08:04:52 +00001563 if (Left.is(tok::coloncolon) ||
1564 (Right.is(tok::period) && Style.Language == FormatStyle::LK_Proto))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001565 return 500;
Daniel Jasper83193602013-04-05 17:22:09 +00001566 if (Left.isOneOf(tok::kw_class, tok::kw_struct))
1567 return 5000;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001568
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001569 if (Left.isOneOf(TT_RangeBasedForLoopColon, TT_InheritanceColon))
Daniel Jasper16b35622013-02-26 13:18:08 +00001570 return 2;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001571
Daniel Jasper4c6e0052013-08-27 14:24:43 +00001572 if (Right.isMemberAccess()) {
Daniel Jasper4d7a97a2014-01-10 08:40:17 +00001573 if (Left.is(tok::r_paren) && Left.MatchingParen &&
Daniel Jasper36c28ce2013-09-06 08:54:24 +00001574 Left.MatchingParen->ParameterCount > 0)
Daniel Jasper70bc8742013-02-26 13:59:14 +00001575 return 20; // Should be smaller than breaking at a nested comma.
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001576 return 150;
1577 }
1578
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001579 if (Right.is(TT_TrailingAnnotation) &&
Daniel Jaspere3f907f2014-06-02 09:52:08 +00001580 (!Right.Next || Right.Next->isNot(tok::l_paren))) {
Daniel Jasperec8e8382014-10-11 08:24:56 +00001581 // Moving trailing annotations to the next line is fine for ObjC method
1582 // declarations.
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001583 if (Line.First->is(TT_ObjCMethodSpecifier))
Daniel Jasperec8e8382014-10-11 08:24:56 +00001584
1585 return 10;
Daniel Jasper5550de62014-02-17 07:57:46 +00001586 // Generally, breaking before a trailing annotation is bad unless it is
1587 // function-like. It seems to be especially preferable to keep standard
1588 // annotations (i.e. "const", "final" and "override") on the same line.
Daniel Jasper43e6a282013-12-16 15:01:54 +00001589 // Use a slightly higher penalty after ")" so that annotations like
1590 // "const override" are kept together.
Daniel Jasperb48d3af2014-04-09 10:01:49 +00001591 bool is_short_annotation = Right.TokenText.size() < 10;
Daniel Jasperb05a81d2014-05-09 13:11:16 +00001592 return (Left.is(tok::r_paren) ? 100 : 120) + (is_short_annotation ? 50 : 0);
Daniel Jasper43e6a282013-12-16 15:01:54 +00001593 }
Daniel Jasper13c37b32013-05-22 08:28:26 +00001594
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001595 // In for-loops, prefer breaking at ',' and ';'.
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001596 if (Line.First->is(tok::kw_for) && Left.is(tok::equal))
Daniel Jasper37905f72013-02-21 15:00:29 +00001597 return 4;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001598
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001599 // In Objective-C method expressions, prefer breaking before "param:" over
1600 // breaking after it.
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001601 if (Right.is(TT_SelectorName))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001602 return 0;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001603 if (Left.is(tok::colon) && Left.is(TT_ObjCMethodExpr))
Daniel Jasper4bf0d802013-11-23 14:27:27 +00001604 return Line.MightBeFunctionDecl ? 50 : 500;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001605
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00001606 if (Left.is(tok::l_paren) && InFunctionDecl && Style.AlignAfterOpenBracket)
Daniel Jasper6728fc12013-04-11 14:29:13 +00001607 return 100;
Daniel Jaspera42de762015-02-26 09:49:08 +00001608 if (Left.is(tok::l_paren) && Left.Previous && Left.Previous->is(tok::kw_if))
1609 return 1000;
Daniel Jasper126153a2013-12-27 06:39:56 +00001610 if (Left.is(tok::equal) && InFunctionDecl)
1611 return 110;
Daniel Jaspera5621202014-08-08 12:00:13 +00001612 if (Right.is(tok::r_brace))
1613 return 1;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001614 if (Left.is(TT_TemplateOpener))
Daniel Jasperea79ea12014-08-15 05:00:39 +00001615 return 100;
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00001616 if (Left.opensScope()) {
1617 if (!Style.AlignAfterOpenBracket)
1618 return 0;
Daniel Jasper33b909c2013-10-25 14:29:37 +00001619 return Left.ParameterCount > 1 ? Style.PenaltyBreakBeforeFirstCallParameter
1620 : 19;
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +00001621 }
Daniel Jasper190fbda2015-01-14 10:36:31 +00001622 if (Left.is(TT_JavaAnnotation))
1623 return 50;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001624
Daniel Jasperba9ddb62013-02-06 21:04:05 +00001625 if (Right.is(tok::lessless)) {
1626 if (Left.is(tok::string_literal)) {
Alexander Kornienkoffcc0102013-06-05 14:09:10 +00001627 StringRef Content = Left.TokenText;
Daniel Jasper0b1f76b2013-09-29 12:02:57 +00001628 if (Content.startswith("\""))
1629 Content = Content.drop_front(1);
1630 if (Content.endswith("\""))
1631 Content = Content.drop_back(1);
1632 Content = Content.trim();
Daniel Jasperf38a0ac2013-03-14 14:00:17 +00001633 if (Content.size() > 1 &&
1634 (Content.back() == ':' || Content.back() == '='))
Daniel Jasperfa21c072013-07-15 14:33:14 +00001635 return 25;
Daniel Jasperba9ddb62013-02-06 21:04:05 +00001636 }
Daniel Jasper49a94482013-07-15 15:04:42 +00001637 return 1; // Breaking at a << is really cheap.
Daniel Jasperba9ddb62013-02-06 21:04:05 +00001638 }
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001639 if (Left.is(TT_ConditionalExpr))
Daniel Jasper70bc8742013-02-26 13:59:14 +00001640 return prec::Conditional;
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001641 prec::Level Level = Left.getPrecedence();
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001642 if (Level != prec::Unknown)
1643 return Level;
Daniel Jasperf9a84b52013-03-01 16:48:32 +00001644
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001645 return 3;
1646}
1647
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001648bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001649 const FormatToken &Left,
1650 const FormatToken &Right) {
Daniel Jasper166c19b2014-05-06 14:12:21 +00001651 if (Left.is(tok::kw_return) && Right.isNot(tok::semi))
1652 return true;
Daniel Jaspere9beea22014-01-28 15:20:33 +00001653 if (Style.ObjCSpaceAfterProperty && Line.Type == LT_ObjCProperty &&
1654 Left.Tok.getObjCKeywordID() == tok::objc_property)
1655 return true;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001656 if (Right.is(tok::hashhash))
1657 return Left.is(tok::hash);
Alexander Kornienko62b85b92013-03-13 14:41:29 +00001658 if (Left.isOneOf(tok::hashhash, tok::hash))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001659 return Right.is(tok::hash);
Daniel Jasperb55acad2013-08-20 12:36:34 +00001660 if (Left.is(tok::l_paren) && Right.is(tok::r_paren))
1661 return Style.SpaceInEmptyParentheses;
1662 if (Left.is(tok::l_paren) || Right.is(tok::r_paren))
Nico Weberbeb03932015-01-09 23:25:06 +00001663 return (Right.is(TT_CastRParen) ||
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001664 (Left.MatchingParen && Left.MatchingParen->is(TT_CastRParen)))
Daniel Jasperb55acad2013-08-20 12:36:34 +00001665 ? Style.SpacesInCStyleCastParentheses
1666 : Style.SpacesInParentheses;
1667 if (Right.isOneOf(tok::semi, tok::comma))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001668 return false;
1669 if (Right.is(tok::less) &&
Daniel Jasper20e15562015-04-16 07:02:19 +00001670 (Left.is(tok::kw_template) ||
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001671 (Line.Type == LT_ObjCDecl && Style.ObjCSpaceBeforeProtocolList)))
1672 return true;
Alexander Kornienko62b85b92013-03-13 14:41:29 +00001673 if (Left.isOneOf(tok::exclaim, tok::tilde))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001674 return false;
1675 if (Left.is(tok::at) &&
Alexander Kornienko62b85b92013-03-13 14:41:29 +00001676 Right.isOneOf(tok::identifier, tok::string_literal, tok::char_constant,
1677 tok::numeric_constant, tok::l_paren, tok::l_brace,
1678 tok::kw_true, tok::kw_false))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001679 return false;
1680 if (Left.is(tok::coloncolon))
1681 return false;
Alexander Kornienko62b85b92013-03-13 14:41:29 +00001682 if (Left.is(tok::less) || Right.isOneOf(tok::greater, tok::less))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001683 return false;
Daniel Jasperbafa6b72013-07-01 09:47:25 +00001684 if (Right.is(tok::ellipsis))
Daniel Jasper2d0cd492013-10-20 16:56:16 +00001685 return Left.Tok.isLiteral();
Manuel Klimekbab25fd2013-09-04 08:20:47 +00001686 if (Left.is(tok::l_square) && Right.is(tok::amp))
1687 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001688 if (Right.is(TT_PointerOrReference))
Daniel Jasper1c220482015-02-25 10:30:06 +00001689 return !(Left.is(tok::r_paren) && Left.MatchingParen &&
1690 (Left.MatchingParen->is(TT_OverloadedOperatorLParen) ||
1691 (Left.MatchingParen->Previous &&
1692 Left.MatchingParen->Previous->is(
1693 TT_FunctionDeclarationName)))) &&
1694 (Left.Tok.isLiteral() ||
1695 (!Left.isOneOf(TT_PointerOrReference, tok::l_paren) &&
Daniel Jasperbea1ab42015-03-01 18:55:26 +00001696 (Style.PointerAlignment != FormatStyle::PAS_Left ||
1697 Line.IsMultiVariableDeclStmt)));
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001698 if (Right.is(TT_FunctionTypeLParen) && Left.isNot(tok::l_paren) &&
1699 (!Left.is(TT_PointerOrReference) ||
Daniel Jasperbea1ab42015-03-01 18:55:26 +00001700 (Style.PointerAlignment != FormatStyle::PAS_Right &&
1701 !Line.IsMultiVariableDeclStmt)))
Daniel Jaspercfda5172013-05-08 14:58:20 +00001702 return true;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001703 if (Left.is(TT_PointerOrReference))
1704 return Right.Tok.isLiteral() || Right.is(TT_BlockComment) ||
1705 (!Right.isOneOf(TT_PointerOrReference, tok::l_paren) &&
Daniel Jasperbea1ab42015-03-01 18:55:26 +00001706 (Style.PointerAlignment != FormatStyle::PAS_Right &&
1707 !Line.IsMultiVariableDeclStmt) &&
1708 Left.Previous &&
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001709 !Left.Previous->isOneOf(tok::l_paren, tok::coloncolon));
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001710 if (Right.is(tok::star) && Left.is(tok::l_paren))
1711 return false;
Nico Weber2a726b62013-02-10 02:08:05 +00001712 if (Left.is(tok::l_square))
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001713 return (Left.is(TT_ArrayInitializerLSquare) &&
Daniel Jasperad981f82014-08-26 11:41:14 +00001714 Style.SpacesInContainerLiterals && Right.isNot(tok::r_square)) ||
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001715 (Left.is(TT_ArraySubscriptLSquare) && Style.SpacesInSquareBrackets &&
1716 Right.isNot(tok::r_square));
Nico Weber2a726b62013-02-10 02:08:05 +00001717 if (Right.is(tok::r_square))
Daniel Jasperad981f82014-08-26 11:41:14 +00001718 return Right.MatchingParen &&
1719 ((Style.SpacesInContainerLiterals &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001720 Right.MatchingParen->is(TT_ArrayInitializerLSquare)) ||
Daniel Jasperad981f82014-08-26 11:41:14 +00001721 (Style.SpacesInSquareBrackets &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001722 Right.MatchingParen->is(TT_ArraySubscriptLSquare)));
1723 if (Right.is(tok::l_square) &&
1724 !Right.isOneOf(TT_ObjCMethodExpr, TT_LambdaLSquare) &&
1725 !Left.isOneOf(tok::numeric_constant, TT_DictLiteral))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001726 return false;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001727 if (Left.is(tok::colon))
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001728 return !Left.is(TT_ObjCMethodExpr);
Daniel Jasper610381f2014-08-26 09:37:52 +00001729 if (Left.is(tok::l_brace) && Right.is(tok::r_brace))
1730 return !Left.Children.empty(); // No spaces in "{}".
1731 if ((Left.is(tok::l_brace) && Left.BlockKind != BK_Block) ||
1732 (Right.is(tok::r_brace) && Right.MatchingParen &&
1733 Right.MatchingParen->BlockKind != BK_Block))
1734 return !Style.Cpp11BracedListStyle;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001735 if (Left.is(TT_BlockComment))
Daniel Jasper484033b2014-05-06 14:41:29 +00001736 return !Left.TokenText.endswith("=*/");
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001737 if (Right.is(tok::l_paren)) {
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001738 if (Left.is(tok::r_paren) && Left.is(TT_AttributeParen))
Daniel Jasperee6d6502013-07-17 20:25:02 +00001739 return true;
Daniel Jasper79121232014-11-27 14:55:17 +00001740 return Line.Type == LT_ObjCDecl || Left.is(tok::semi) ||
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00001741 (Style.SpaceBeforeParens != FormatStyle::SBPO_Never &&
Daniel Jaspere1e43192014-04-01 12:55:11 +00001742 (Left.isOneOf(tok::kw_if, tok::kw_for, tok::kw_while,
Daniel Jasper8f2e94c2014-09-04 15:03:34 +00001743 tok::kw_switch, tok::kw_case) ||
Nico Weberfac23712015-02-04 15:26:27 +00001744 (Left.isOneOf(tok::kw_try, Keywords.kw___except, tok::kw_catch,
1745 tok::kw_new, tok::kw_delete) &&
Daniel Jasper8f2e94c2014-09-04 15:03:34 +00001746 (!Left.Previous || Left.Previous->isNot(tok::period))) ||
Daniel Jaspere1e43192014-04-01 12:55:11 +00001747 Left.IsForEachMacro)) ||
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00001748 (Style.SpaceBeforeParens == FormatStyle::SBPO_Always &&
Daniel Jasper78b194992014-08-06 14:15:41 +00001749 (Left.is(tok::identifier) || Left.isFunctionLikeKeyword()) &&
Alexander Kornienkofdca83d2013-12-10 10:18:34 +00001750 Line.Type != LT_PreprocessorDirective);
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001751 }
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001752 if (Left.is(tok::at) && Right.Tok.getObjCKeywordID() != tok::objc_not_keyword)
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001753 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001754 if (Right.is(TT_UnaryOperator))
Daniel Jasper5bd0b9e2013-05-23 18:05:18 +00001755 return !Left.isOneOf(tok::l_paren, tok::l_square, tok::at) &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001756 (Left.isNot(tok::colon) || Left.isNot(TT_ObjCMethodExpr));
Daniel Jasper4afc6b32014-06-02 10:57:55 +00001757 if ((Left.isOneOf(tok::identifier, tok::greater, tok::r_square,
1758 tok::r_paren) ||
Daniel Jasper7a2d60e2014-05-07 07:59:03 +00001759 Left.isSimpleTypeSpecifier()) &&
Manuel Klimekbab25fd2013-09-04 08:20:47 +00001760 Right.is(tok::l_brace) && Right.getNextNonComment() &&
1761 Right.BlockKind != BK_Block)
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001762 return false;
Daniel Jasperbca4bbe2013-05-28 11:30:49 +00001763 if (Left.is(tok::period) || Right.is(tok::period))
1764 return false;
Alexander Kornienkod8d47fa2013-09-10 13:41:43 +00001765 if (Right.is(tok::hash) && Left.is(tok::identifier) && Left.TokenText == "L")
1766 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001767 if (Left.is(TT_TemplateCloser) && Left.MatchingParen &&
Daniel Jasper5ffcb7f2014-10-21 11:13:31 +00001768 Left.MatchingParen->Previous &&
1769 Left.MatchingParen->Previous->is(tok::period))
1770 // A.<B>DoSomething();
1771 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001772 if (Left.is(TT_TemplateCloser) && Right.is(tok::l_square))
Daniel Jasper6761b422014-11-18 23:48:01 +00001773 return false;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001774 return true;
1775}
1776
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001777bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line,
Daniel Jasper38efc132014-10-21 07:51:54 +00001778 const FormatToken &Right) {
1779 const FormatToken &Left = *Right.Previous;
1780 if (Style.Language == FormatStyle::LK_Proto) {
1781 if (Right.is(tok::period) &&
Daniel Jasperd0ec0d62014-11-04 12:41:02 +00001782 Left.isOneOf(Keywords.kw_optional, Keywords.kw_required,
1783 Keywords.kw_repeated))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001784 return true;
Daniel Jasper38efc132014-10-21 07:51:54 +00001785 if (Right.is(tok::l_paren) &&
Daniel Jasperd0ec0d62014-11-04 12:41:02 +00001786 Left.isOneOf(Keywords.kw_returns, Keywords.kw_option))
Daniel Jasper38efc132014-10-21 07:51:54 +00001787 return true;
1788 } else if (Style.Language == FormatStyle::LK_JavaScript) {
Daniel Jasperd0ec0d62014-11-04 12:41:02 +00001789 if (Left.is(Keywords.kw_var))
Daniel Jasper38efc132014-10-21 07:51:54 +00001790 return true;
Daniel Jaspera74f5072015-04-13 15:01:40 +00001791 if (Right.isOneOf(TT_JsTypeColon, TT_JsTypeOptionalQuestion))
Daniel Jasperb10bdff2015-02-18 17:09:53 +00001792 return false;
Daniel Jasper354aa512015-02-19 16:07:32 +00001793 if ((Left.is(tok::l_brace) || Right.is(tok::r_brace)) &&
Daniel Jasperfca735c2015-02-19 16:14:18 +00001794 Line.First->isOneOf(Keywords.kw_import, tok::kw_export))
Daniel Jasper354aa512015-02-19 16:07:32 +00001795 return false;
Daniel Jasperbc46b932015-03-15 13:59:51 +00001796 if (Left.is(TT_TemplateCloser) &&
1797 !Right.isOneOf(tok::l_brace, tok::comma, tok::l_square,
1798 Keywords.kw_implements, Keywords.kw_extends))
1799 // Type assertions ('<type>expr') are not followed by whitespace. Other
1800 // locations that should have whitespace following are identified by the
1801 // above set of follower tokens.
1802 return false;
Daniel Jasperb9d3db62014-11-02 22:00:57 +00001803 } else if (Style.Language == FormatStyle::LK_Java) {
Daniel Jaspera0143fa2014-11-23 20:54:37 +00001804 if (Left.is(tok::r_square) && Right.is(tok::l_brace))
1805 return true;
Daniel Jasper8354ea82014-11-21 12:14:12 +00001806 if (Left.is(TT_LambdaArrow) || Right.is(TT_LambdaArrow))
1807 return true;
Daniel Jasperd0ec0d62014-11-04 12:41:02 +00001808 if (Left.is(Keywords.kw_synchronized) && Right.is(tok::l_paren))
Daniel Jasperb9d3db62014-11-02 22:00:57 +00001809 return Style.SpaceBeforeParens != FormatStyle::SBPO_Never;
Daniel Jasper82c92752014-11-21 12:19:07 +00001810 if ((Left.isOneOf(tok::kw_static, tok::kw_public, tok::kw_private,
1811 tok::kw_protected) ||
Nico Webered501662015-01-13 22:32:50 +00001812 Left.isOneOf(Keywords.kw_final, Keywords.kw_abstract,
1813 Keywords.kw_native)) &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001814 Right.is(TT_TemplateOpener))
Daniel Jasperdb9a7a22014-11-03 02:35:14 +00001815 return true;
Daniel Jasper38efc132014-10-21 07:51:54 +00001816 }
1817 if (Right.Tok.getIdentifierInfo() && Left.Tok.getIdentifierInfo())
1818 return true; // Never ever merge two identifiers.
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001819 if (Left.is(TT_ImplicitStringLiteral))
Daniel Jasper38efc132014-10-21 07:51:54 +00001820 return Right.WhitespaceRange.getBegin() != Right.WhitespaceRange.getEnd();
1821 if (Line.Type == LT_ObjCMethodDecl) {
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001822 if (Left.is(TT_ObjCMethodSpecifier))
Daniel Jasper38efc132014-10-21 07:51:54 +00001823 return true;
1824 if (Left.is(tok::r_paren) && Right.is(tok::identifier))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001825 // Don't space between ')' and <id>
1826 return false;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001827 }
1828 if (Line.Type == LT_ObjCProperty &&
Daniel Jasper38efc132014-10-21 07:51:54 +00001829 (Right.is(tok::equal) || Left.is(tok::equal)))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001830 return false;
1831
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001832 if (Right.is(TT_TrailingReturnArrow) || Left.is(TT_TrailingReturnArrow))
Daniel Jasper6cdec7c2013-07-09 14:36:48 +00001833 return true;
Daniel Jasper38efc132014-10-21 07:51:54 +00001834 if (Left.is(tok::comma))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001835 return true;
Daniel Jasper38efc132014-10-21 07:51:54 +00001836 if (Right.is(tok::comma))
Daniel Jasperff6c3a92013-02-28 13:40:17 +00001837 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001838 if (Right.isOneOf(TT_CtorInitializerColon, TT_ObjCBlockLParen))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001839 return true;
Daniel Jasper38efc132014-10-21 07:51:54 +00001840 if (Left.is(tok::kw_operator))
1841 return Right.is(tok::coloncolon);
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001842 if (Right.is(TT_OverloadedOperatorLParen))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001843 return false;
Daniel Jasper38efc132014-10-21 07:51:54 +00001844 if (Right.is(tok::colon))
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001845 return !Line.First->isOneOf(tok::kw_case, tok::kw_default) &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001846 Right.getNextNonComment() && Right.isNot(TT_ObjCMethodExpr) &&
Daniel Jasper38efc132014-10-21 07:51:54 +00001847 !Left.is(tok::question) &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001848 !(Right.is(TT_InlineASMColon) && Left.is(tok::coloncolon)) &&
1849 (Right.isNot(TT_DictLiteral) || Style.SpacesInContainerLiterals);
1850 if (Left.is(TT_UnaryOperator))
1851 return Right.is(TT_BinaryOperator);
1852 if (Left.is(TT_CastRParen))
1853 return Style.SpaceAfterCStyleCast || Right.is(TT_BinaryOperator);
Daniel Jasper38efc132014-10-21 07:51:54 +00001854 if (Left.is(tok::greater) && Right.is(tok::greater)) {
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001855 return Right.is(TT_TemplateCloser) && Left.is(TT_TemplateCloser) &&
Daniel Jasperdd978ae2013-10-29 14:52:02 +00001856 (Style.Standard != FormatStyle::LS_Cpp11 || Style.SpacesInAngles);
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001857 }
Daniel Jasper38efc132014-10-21 07:51:54 +00001858 if (Right.isOneOf(tok::arrow, tok::period, tok::arrowstar, tok::periodstar) ||
1859 Left.isOneOf(tok::arrow, tok::period, tok::arrowstar, tok::periodstar))
Daniel Jasperff6c3a92013-02-28 13:40:17 +00001860 return false;
Daniel Jasperd94bff32013-09-25 15:15:02 +00001861 if (!Style.SpaceBeforeAssignmentOperators &&
Daniel Jasper38efc132014-10-21 07:51:54 +00001862 Right.getPrecedence() == prec::Assignment)
Daniel Jasperd94bff32013-09-25 15:15:02 +00001863 return false;
Daniel Jasper16b107e2014-10-21 09:57:09 +00001864 if (Right.is(tok::coloncolon) && Left.isNot(tok::l_brace))
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001865 return (Left.is(TT_TemplateOpener) &&
Daniel Jasperf322eb52014-10-23 20:22:22 +00001866 Style.Standard == FormatStyle::LS_Cpp03) ||
1867 !(Left.isOneOf(tok::identifier, tok::l_paren, tok::r_paren) ||
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001868 Left.isOneOf(TT_TemplateCloser, TT_TemplateOpener));
1869 if ((Left.is(TT_TemplateOpener)) != (Right.is(TT_TemplateCloser)))
Daniel Jasper16b107e2014-10-21 09:57:09 +00001870 return Style.SpacesInAngles;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001871 if ((Right.is(TT_BinaryOperator) && !Left.is(tok::l_paren)) ||
1872 Left.isOneOf(TT_BinaryOperator, TT_ConditionalExpr))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001873 return true;
Daniel Jasperbeaa3222015-02-26 11:30:50 +00001874 if (Left.is(TT_TemplateCloser) && Right.is(tok::l_paren) &&
1875 Right.isNot(TT_FunctionTypeLParen))
Chad Rosier0a84f172014-08-05 17:58:54 +00001876 return Style.SpaceBeforeParens == FormatStyle::SBPO_Always;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001877 if (Right.is(TT_TemplateOpener) && Left.is(tok::r_paren) &&
1878 Left.MatchingParen && Left.MatchingParen->is(TT_OverloadedOperatorLParen))
Daniel Jasper8835a322014-10-20 13:56:30 +00001879 return false;
Daniel Jasper38efc132014-10-21 07:51:54 +00001880 if (Right.is(tok::less) && Left.isNot(tok::l_paren) &&
Daniel Jaspered8f1c62013-08-28 08:24:04 +00001881 Line.First->is(tok::hash))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001882 return true;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001883 if (Right.is(TT_TrailingUnaryOperator))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001884 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001885 if (Left.is(TT_RegexLiteral))
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001886 return false;
Daniel Jasper38efc132014-10-21 07:51:54 +00001887 return spaceRequiredBetween(Line, Left, Right);
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00001888}
1889
Daniel Jaspere18ff372014-06-02 10:17:32 +00001890// Returns 'true' if 'Tok' is a brace we'd want to break before in Allman style.
1891static bool isAllmanBrace(const FormatToken &Tok) {
1892 return Tok.is(tok::l_brace) && Tok.BlockKind == BK_Block &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001893 !Tok.isOneOf(TT_ObjCBlockLBrace, TT_DictLiteral);
Daniel Jaspere18ff372014-06-02 10:17:32 +00001894}
1895
Daniel Jasperfb81b092013-09-17 09:52:48 +00001896bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line,
1897 const FormatToken &Right) {
Daniel Jaspera125d532014-03-21 12:38:57 +00001898 const FormatToken &Left = *Right.Previous;
Daniel Jaspera69ca9b2014-06-04 12:40:57 +00001899 if (Right.NewlinesBefore > 1)
1900 return true;
Daniel Jasper64a328e2014-11-11 19:34:57 +00001901
1902 // If the last token before a '}' is a comma or a trailing comment, the
1903 // intention is to insert a line break after it in order to make shuffling
1904 // around entries easier.
1905 const FormatToken *BeforeClosingBrace = nullptr;
Daniel Jasper308062b2015-02-27 08:41:05 +00001906 if (Left.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&
1907 Left.BlockKind != BK_Block && Left.MatchingParen)
Daniel Jasper64a328e2014-11-11 19:34:57 +00001908 BeforeClosingBrace = Left.MatchingParen->Previous;
Daniel Jasper308062b2015-02-27 08:41:05 +00001909 else if (Right.MatchingParen &&
1910 Right.MatchingParen->isOneOf(tok::l_brace,
1911 TT_ArrayInitializerLSquare))
Daniel Jasper64a328e2014-11-11 19:34:57 +00001912 BeforeClosingBrace = &Left;
1913 if (BeforeClosingBrace && (BeforeClosingBrace->is(tok::comma) ||
1914 BeforeClosingBrace->isTrailingComment()))
1915 return true;
1916
Daniel Jasperd05d3a82015-01-08 13:56:57 +00001917 if (Right.is(tok::comment))
Daniel Jasper64a328e2014-11-11 19:34:57 +00001918 return Left.BlockKind != BK_BracedInit &&
Daniel Jaspera98b7b02014-11-25 10:05:17 +00001919 Left.isNot(TT_CtorInitializerColon) &&
Manuel Klimek1fcbe672014-04-11 12:27:47 +00001920 (Right.NewlinesBefore > 0 && Right.HasUnescapedNewline);
Daniel Jasperd05d3a82015-01-08 13:56:57 +00001921 if (Right.Previous->isTrailingComment() ||
1922 (Right.isStringLiteral() && Right.Previous->isStringLiteral()))
Daniel Jasperfb81b092013-09-17 09:52:48 +00001923 return true;
Daniel Jasperd05d3a82015-01-08 13:56:57 +00001924 if (Right.Previous->IsUnterminatedLiteral)
Daniel Jasperfb81b092013-09-17 09:52:48 +00001925 return true;
Daniel Jasperd05d3a82015-01-08 13:56:57 +00001926 if (Right.is(tok::lessless) && Right.Next &&
1927 Right.Previous->is(tok::string_literal) &&
1928 Right.Next->is(tok::string_literal))
Daniel Jasperfb81b092013-09-17 09:52:48 +00001929 return true;
Daniel Jasperd05d3a82015-01-08 13:56:57 +00001930 if (Right.Previous->ClosesTemplateDeclaration &&
1931 Right.Previous->MatchingParen &&
1932 Right.Previous->MatchingParen->NestingLevel == 0 &&
1933 Style.AlwaysBreakTemplateDeclarations)
Daniel Jasperfb81b092013-09-17 09:52:48 +00001934 return true;
Daniel Jasperd05d3a82015-01-08 13:56:57 +00001935 if ((Right.isOneOf(TT_CtorInitializerComma, TT_CtorInitializerColon)) &&
1936 Style.BreakConstructorInitializersBeforeComma &&
1937 !Style.ConstructorInitializerAllOnOneLineOrOnePerLine)
Daniel Jasperfb81b092013-09-17 09:52:48 +00001938 return true;
Daniel Jasperd05d3a82015-01-08 13:56:57 +00001939 if (Right.is(tok::string_literal) && Right.TokenText.startswith("R\""))
Daniel Jasperc39b56f2013-12-16 07:23:08 +00001940 // Raw string literals are special wrt. line breaks. The author has made a
1941 // deliberate choice and might have aligned the contents of the string
1942 // literal accordingly. Thus, we try keep existing line breaks.
1943 return Right.NewlinesBefore > 0;
Daniel Jasperd05d3a82015-01-08 13:56:57 +00001944 if (Right.Previous->is(tok::l_brace) && Right.NestingLevel == 1 &&
1945 Style.Language == FormatStyle::LK_Proto)
Daniel Jasperce2fdb02014-10-27 13:25:59 +00001946 // Don't put enums onto single lines in protocol buffers.
Daniel Jasper7052ce62014-01-19 09:04:08 +00001947 return true;
Daniel Jasperd05d3a82015-01-08 13:56:57 +00001948 if (Style.Language == FormatStyle::LK_JavaScript && Right.is(tok::r_brace) &&
1949 Left.is(tok::l_brace) && !Left.Children.empty())
Daniel Jasper67f8ad22014-09-30 17:57:06 +00001950 // Support AllowShortFunctionsOnASingleLine for JavaScript.
1951 return Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_None ||
1952 (Left.NestingLevel == 0 && Line.Level == 0 &&
1953 Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_Inline);
Daniel Jasperd05d3a82015-01-08 13:56:57 +00001954 if (isAllmanBrace(Left) || isAllmanBrace(Right))
Daniel Jaspere18ff372014-06-02 10:17:32 +00001955 return Style.BreakBeforeBraces == FormatStyle::BS_Allman ||
1956 Style.BreakBeforeBraces == FormatStyle::BS_GNU;
Daniel Jasperd05d3a82015-01-08 13:56:57 +00001957 if (Style.Language == FormatStyle::LK_Proto && Left.isNot(tok::l_brace) &&
1958 Right.is(TT_SelectorName))
Daniel Jaspera382cbe2014-07-28 14:08:09 +00001959 return true;
Daniel Jasperd05d3a82015-01-08 13:56:57 +00001960 if (Left.is(TT_ObjCBlockLBrace) && !Style.AllowShortBlocksOnASingleLine)
Daniel Jasper76284682014-10-22 09:12:44 +00001961 return true;
Daniel Jasperb175d572014-04-09 09:53:23 +00001962
Daniel Jasper354aa512015-02-19 16:07:32 +00001963 if ((Style.Language == FormatStyle::LK_Java ||
1964 Style.Language == FormatStyle::LK_JavaScript) &&
1965 Left.is(TT_LeadingJavaAnnotation) &&
1966 Right.isNot(TT_LeadingJavaAnnotation) && Right.isNot(tok::l_paren) &&
1967 Line.Last->is(tok::l_brace))
1968 return true;
1969
Daniel Jasper49802ef2014-05-22 09:10:04 +00001970 if (Style.Language == FormatStyle::LK_JavaScript) {
1971 // FIXME: This might apply to other languages and token kinds.
1972 if (Right.is(tok::char_constant) && Left.is(tok::plus) && Left.Previous &&
1973 Left.Previous->is(tok::char_constant))
1974 return true;
Daniel Jaspera4e55f42014-12-04 16:07:17 +00001975 if (Left.is(TT_DictLiteral) && Left.is(tok::l_brace) &&
Daniel Jasper60948b12015-03-15 13:55:54 +00001976 Left.NestingLevel == 0 && Left.Previous &&
1977 Left.Previous->is(tok::equal) &&
1978 Line.First->isOneOf(tok::identifier, Keywords.kw_import,
1979 tok::kw_export) &&
1980 // kw_var is a pseudo-token that's a tok::identifier, so matches above.
1981 !Line.First->is(Keywords.kw_var))
1982 // Enum style object literal.
Daniel Jaspera4e55f42014-12-04 16:07:17 +00001983 return true;
Daniel Jasperfab69ff2014-10-21 08:24:18 +00001984 } else if (Style.Language == FormatStyle::LK_Java) {
Daniel Jasperc0126862014-10-21 11:34:53 +00001985 if (Right.is(tok::plus) && Left.is(tok::string_literal) && Right.Next &&
1986 Right.Next->is(tok::string_literal))
1987 return true;
Daniel Jasper49802ef2014-05-22 09:10:04 +00001988 }
1989
Daniel Jasperfb81b092013-09-17 09:52:48 +00001990 return false;
1991}
1992
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001993bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line,
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001994 const FormatToken &Right) {
1995 const FormatToken &Left = *Right.Previous;
Daniel Jasperf26c7552014-10-17 13:36:14 +00001996
1997 if (Style.Language == FormatStyle::LK_Java) {
Daniel Jasperd0ec0d62014-11-04 12:41:02 +00001998 if (Left.isOneOf(Keywords.kw_throws, Keywords.kw_extends,
1999 Keywords.kw_implements))
Daniel Jasperf26c7552014-10-17 13:36:14 +00002000 return false;
Daniel Jasperd0ec0d62014-11-04 12:41:02 +00002001 if (Right.isOneOf(Keywords.kw_throws, Keywords.kw_extends,
2002 Keywords.kw_implements))
Daniel Jasper58fcf6d2014-11-04 10:53:14 +00002003 return true;
Daniel Jasperf26c7552014-10-17 13:36:14 +00002004 }
2005
Daniel Jasper4bf0d802013-11-23 14:27:27 +00002006 if (Left.is(tok::at))
2007 return false;
Daniel Jasper437c3f52014-04-28 07:34:48 +00002008 if (Left.Tok.getObjCKeywordID() == tok::objc_interface)
2009 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002010 if (Left.isOneOf(TT_JavaAnnotation, TT_LeadingJavaAnnotation))
Daniel Jasper3e1bd142015-01-14 09:51:32 +00002011 return !Right.is(tok::l_paren);
Daniel Jasperb754a742015-03-12 15:04:53 +00002012 if (Right.is(TT_PointerOrReference))
2013 return Line.IsMultiVariableDeclStmt ||
2014 (Style.PointerAlignment == FormatStyle::PAS_Right &&
2015 (!Right.Next || Right.Next->isNot(TT_FunctionDeclarationName)));
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002016 if (Right.isOneOf(TT_StartOfName, TT_FunctionDeclarationName) ||
2017 Right.is(tok::kw_operator))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00002018 return true;
Daniel Jasper414c9c62015-03-19 09:40:16 +00002019 if (Left.is(TT_PointerOrReference))
2020 return false;
Daniel Jasper165b29e2013-11-08 00:57:11 +00002021 if (Right.isTrailingComment())
2022 // We rely on MustBreakBefore being set correctly here as we should not
2023 // change the "binding" behavior of a comment.
Daniel Jasper5a611392013-12-19 21:41:37 +00002024 // The first comment in a braced lists is always interpreted as belonging to
2025 // the first list element. Otherwise, it should be placed outside of the
2026 // list.
2027 return Left.BlockKind == BK_BracedInit;
Daniel Jasper165b29e2013-11-08 00:57:11 +00002028 if (Left.is(tok::question) && Right.is(tok::colon))
2029 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002030 if (Right.is(TT_ConditionalExpr) || Right.is(tok::question))
Daniel Jasper165b29e2013-11-08 00:57:11 +00002031 return Style.BreakBeforeTernaryOperators;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002032 if (Left.is(TT_ConditionalExpr) || Left.is(tok::question))
Daniel Jasper165b29e2013-11-08 00:57:11 +00002033 return !Style.BreakBeforeTernaryOperators;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002034 if (Right.is(TT_InheritanceColon))
Daniel Jasper3a122c02014-02-14 18:22:40 +00002035 return true;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002036 if (Right.is(tok::colon) &&
2037 !Right.isOneOf(TT_CtorInitializerColon, TT_InlineASMColon))
Daniel Jasperd39312ec2014-05-28 10:09:11 +00002038 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002039 if (Left.is(tok::colon) && (Left.isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00002040 return true;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002041 if (Right.is(TT_SelectorName))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00002042 return true;
Daniel Jasper9688ff12013-08-01 13:46:58 +00002043 if (Left.is(tok::r_paren) && Line.Type == LT_ObjCProperty)
2044 return true;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00002045 if (Left.ClosesTemplateDeclaration)
2046 return true;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002047 if (Right.isOneOf(TT_RangeBasedForLoopColon, TT_OverloadedOperatorLParen,
2048 TT_OverloadedOperator))
Daniel Jaspereead02b2013-02-14 08:42:54 +00002049 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002050 if (Left.is(TT_RangeBasedForLoopColon))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00002051 return true;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002052 if (Right.is(TT_RangeBasedForLoopColon))
Daniel Jasper37905f72013-02-21 15:00:29 +00002053 return false;
Daniel Jasperb754a742015-03-12 15:04:53 +00002054 if (Left.isOneOf(TT_TemplateCloser, TT_UnaryOperator) ||
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002055 Left.is(tok::kw_operator))
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00002056 return false;
2057 if (Left.is(tok::equal) && Line.Type == LT_VirtualFunctionDecl)
2058 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002059 if (Left.is(tok::l_paren) && Left.is(TT_AttributeParen))
Daniel Jasper559b63c2014-01-28 20:13:43 +00002060 return false;
2061 if (Left.is(tok::l_paren) && Left.Previous &&
Daniel Jaspera42de762015-02-26 09:49:08 +00002062 (Left.Previous->isOneOf(TT_BinaryOperator, TT_CastRParen)))
Daniel Jasper559b63c2014-01-28 20:13:43 +00002063 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002064 if (Right.is(TT_ImplicitStringLiteral))
Daniel Jasper98857842013-10-30 13:54:53 +00002065 return false;
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00002066
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002067 if (Right.is(tok::r_paren) || Right.is(TT_TemplateCloser))
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00002068 return false;
2069
Daniel Jasper13c37b32013-05-22 08:28:26 +00002070 // We only break before r_brace if there was a corresponding break before
2071 // the l_brace, which is tracked by BreakBeforeClosingBrace.
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00002072 if (Right.is(tok::r_brace))
2073 return Right.MatchingParen && Right.MatchingParen->BlockKind == BK_Block;
Daniel Jasper13c37b32013-05-22 08:28:26 +00002074
Daniel Jasperf9a09062014-04-09 10:29:11 +00002075 // Allow breaking after a trailing annotation, e.g. after a method
2076 // declaration.
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002077 if (Left.is(TT_TrailingAnnotation))
Daniel Jasperf9a09062014-04-09 10:29:11 +00002078 return !Right.isOneOf(tok::l_brace, tok::semi, tok::equal, tok::l_paren,
2079 tok::less, tok::coloncolon);
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00002080
Daniel Jasperbf4755b2013-03-14 09:50:46 +00002081 if (Right.is(tok::kw___attribute))
2082 return true;
2083
Daniel Jasperaf5ba0e2013-02-23 07:46:38 +00002084 if (Left.is(tok::identifier) && Right.is(tok::string_literal))
2085 return true;
Daniel Jaspere33d4af2013-07-26 16:56:36 +00002086
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002087 if (Right.is(tok::identifier) && Right.Next && Right.Next->is(TT_DictLiteral))
Daniel Jasper783bac62014-04-15 09:54:30 +00002088 return true;
2089
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002090 if (Left.is(TT_CtorInitializerComma) &&
Daniel Jaspere33d4af2013-07-26 16:56:36 +00002091 Style.BreakConstructorInitializersBeforeComma)
2092 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002093 if (Right.is(TT_CtorInitializerComma) &&
Daniel Jasperec01cd62013-10-08 05:11:18 +00002094 Style.BreakConstructorInitializersBeforeComma)
2095 return true;
Jacques Pienaarfc275112015-02-18 23:48:37 +00002096 if ((Left.is(tok::greater) && Right.is(tok::greater)) ||
2097 (Left.is(tok::less) && Right.is(tok::less)))
Daniel Jasper0de8efa2013-09-17 08:15:46 +00002098 return false;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002099 if (Right.is(TT_BinaryOperator) &&
Daniel Jasperac043c92014-09-15 11:11:00 +00002100 Style.BreakBeforeBinaryOperators != FormatStyle::BOS_None &&
2101 (Style.BreakBeforeBinaryOperators == FormatStyle::BOS_All ||
2102 Right.getPrecedence() != prec::Assignment))
Daniel Jasper0a1e5ac2014-05-13 08:01:47 +00002103 return true;
Daniel Jaspera98b7b02014-11-25 10:05:17 +00002104 if (Left.is(TT_ArrayInitializerLSquare))
Daniel Jasper1db6c382013-10-22 15:30:28 +00002105 return true;
Daniel Jasper598dd332014-08-12 13:22:26 +00002106 if (Right.is(tok::kw_typename) && Left.isNot(tok::kw_const))
2107 return true;
Daniel Jasperac043c92014-09-15 11:11:00 +00002108 if (Left.isBinaryOperator() && !Left.isOneOf(tok::arrowstar, tok::lessless) &&
2109 Style.BreakBeforeBinaryOperators != FormatStyle::BOS_All &&
2110 (Style.BreakBeforeBinaryOperators == FormatStyle::BOS_None ||
2111 Left.getPrecedence() == prec::Assignment))
2112 return true;
2113 return Left.isOneOf(tok::comma, tok::coloncolon, tok::semi, tok::l_brace,
Daniel Jasper83193602013-04-05 17:22:09 +00002114 tok::kw_class, tok::kw_struct) ||
Daniel Jasper05cd9292015-03-26 18:46:28 +00002115 Right.isMemberAccess() ||
2116 Right.isOneOf(TT_TrailingReturnArrow, TT_LambdaArrow, tok::lessless,
2117 tok::colon, tok::l_square, tok::at) ||
Daniel Jasper1bc1b502013-07-05 07:58:34 +00002118 (Left.is(tok::r_paren) &&
Daniel Jasper559b63c2014-01-28 20:13:43 +00002119 Right.isOneOf(tok::identifier, tok::kw_const)) ||
Daniel Jasper1db6c382013-10-22 15:30:28 +00002120 (Left.is(tok::l_paren) && !Right.is(tok::r_paren));
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00002121}
2122
Daniel Jasper6bee6822013-04-08 20:33:42 +00002123void TokenAnnotator::printDebugInfo(const AnnotatedLine &Line) {
2124 llvm::errs() << "AnnotatedTokens:\n";
Manuel Klimek6e6310e2013-05-29 14:47:47 +00002125 const FormatToken *Tok = Line.First;
Daniel Jasper6bee6822013-04-08 20:33:42 +00002126 while (Tok) {
Manuel Klimek6e6310e2013-05-29 14:47:47 +00002127 llvm::errs() << " M=" << Tok->MustBreakBefore
Daniel Jasperb10cbc42013-07-10 14:02:49 +00002128 << " C=" << Tok->CanBreakBefore << " T=" << Tok->Type
2129 << " S=" << Tok->SpacesRequiredBefore
Daniel Jasper17062ff2014-06-10 14:44:02 +00002130 << " B=" << Tok->BlockParameterCount
Daniel Jasperb10cbc42013-07-10 14:02:49 +00002131 << " P=" << Tok->SplitPenalty << " Name=" << Tok->Tok.getName()
Manuel Klimek71814b42013-10-11 21:25:45 +00002132 << " L=" << Tok->TotalLength << " PPK=" << Tok->PackingKind
2133 << " FakeLParens=";
Daniel Jasper6bee6822013-04-08 20:33:42 +00002134 for (unsigned i = 0, e = Tok->FakeLParens.size(); i != e; ++i)
2135 llvm::errs() << Tok->FakeLParens[i] << "/";
2136 llvm::errs() << " FakeRParens=" << Tok->FakeRParens << "\n";
Daniel Jasperb05a81d2014-05-09 13:11:16 +00002137 if (!Tok->Next)
Manuel Klimek71814b42013-10-11 21:25:45 +00002138 assert(Tok == Line.Last);
Manuel Klimek6e6310e2013-05-29 14:47:47 +00002139 Tok = Tok->Next;
Daniel Jasper6bee6822013-04-08 20:33:42 +00002140 }
2141 llvm::errs() << "----\n";
2142}
2143
Daniel Jasper7a6d09b2013-01-29 21:01:14 +00002144} // namespace format
2145} // namespace clang