blob: 9a52f8265713f38c177fa42f0e7f8e4b21a9807e [file] [log] [blame]
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001//===--- TokenAnnotator.cpp - Format C++ code -----------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9///
10/// \file
11/// \brief This file implements a token annotator, i.e. creates
12/// \c AnnotatedTokens out of \c FormatTokens with required extra information.
13///
14//===----------------------------------------------------------------------===//
15
16#include "TokenAnnotator.h"
17#include "clang/Basic/SourceManager.h"
18#include "clang/Lex/Lexer.h"
19
20namespace clang {
21namespace format {
22
Nico Weberee0feec2013-02-05 16:21:00 +000023static bool isUnaryOperator(const AnnotatedToken &Tok) {
24 switch (Tok.FormatTok.Tok.getKind()) {
25 case tok::plus:
26 case tok::plusplus:
27 case tok::minus:
28 case tok::minusminus:
29 case tok::exclaim:
30 case tok::tilde:
31 case tok::kw_sizeof:
32 case tok::kw_alignof:
33 return true;
34 default:
35 return false;
36 }
37}
38
Daniel Jasper32d28ee2013-01-29 21:01:14 +000039static bool isBinaryOperator(const AnnotatedToken &Tok) {
40 // Comma is a binary operator, but does not behave as such wrt. formatting.
41 return getPrecedence(Tok) > prec::Comma;
42}
43
Daniel Jasper01786732013-02-04 07:21:18 +000044// Returns the previous token ignoring comments.
Nico Weber4ed7f3e2013-02-06 16:54:35 +000045static AnnotatedToken *getPreviousToken(AnnotatedToken &Tok) {
46 AnnotatedToken *PrevToken = Tok.Parent;
Daniel Jasper01786732013-02-04 07:21:18 +000047 while (PrevToken != NULL && PrevToken->is(tok::comment))
48 PrevToken = PrevToken->Parent;
49 return PrevToken;
50}
Nico Weber4ed7f3e2013-02-06 16:54:35 +000051static const AnnotatedToken *getPreviousToken(const AnnotatedToken &Tok) {
52 return getPreviousToken(const_cast<AnnotatedToken &>(Tok));
53}
Daniel Jasper01786732013-02-04 07:21:18 +000054
Daniel Jasper29f123b2013-02-08 15:28:42 +000055static bool isTrailingComment(AnnotatedToken *Tok) {
56 return Tok != NULL && Tok->is(tok::comment) &&
57 (Tok->Children.empty() ||
58 Tok->Children[0].FormatTok.NewlinesBefore > 0);
59}
60
Daniel Jasper01786732013-02-04 07:21:18 +000061// Returns the next token ignoring comments.
62static const AnnotatedToken *getNextToken(const AnnotatedToken &Tok) {
63 if (Tok.Children.empty())
64 return NULL;
65 const AnnotatedToken *NextToken = &Tok.Children[0];
66 while (NextToken->is(tok::comment)) {
67 if (NextToken->Children.empty())
68 return NULL;
69 NextToken = &NextToken->Children[0];
70 }
71 return NextToken;
72}
73
Daniel Jasper32d28ee2013-01-29 21:01:14 +000074/// \brief A parser that gathers additional information about tokens.
75///
76/// The \c TokenAnnotator tries to matches parenthesis and square brakets and
77/// store a parenthesis levels. It also tries to resolve matching "<" and ">"
78/// into template parameter lists.
79class AnnotatingParser {
80public:
Nico Weberc2e6d2a2013-02-11 15:32:15 +000081 AnnotatingParser(SourceManager &SourceMgr, Lexer &Lex, AnnotatedLine &Line,
82 IdentifierInfo &Ident_in)
Daniel Jasper01786732013-02-04 07:21:18 +000083 : SourceMgr(SourceMgr), Lex(Lex), Line(Line), CurrentToken(&Line.First),
Nico Weberc2e6d2a2013-02-11 15:32:15 +000084 KeywordVirtualFound(false), Ident_in(Ident_in) {
Daniel Jasper4e778092013-02-06 10:05:46 +000085 Contexts.push_back(Context(1, /*IsExpression=*/ false));
86 Contexts.back().LookForFunctionName = Line.MustBeDeclaration;
Daniel Jasper32d28ee2013-01-29 21:01:14 +000087 }
88
Nico Weber95e8e462013-02-12 16:17:07 +000089private:
Daniel Jasper32d28ee2013-01-29 21:01:14 +000090 bool parseAngle() {
91 if (CurrentToken == NULL)
92 return false;
Daniel Jasper4e778092013-02-06 10:05:46 +000093 ScopedContextCreator ContextCreator(*this, 10);
Daniel Jasper32d28ee2013-01-29 21:01:14 +000094 AnnotatedToken *Left = CurrentToken->Parent;
Daniel Jasper4e778092013-02-06 10:05:46 +000095 Contexts.back().IsExpression = false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +000096 while (CurrentToken != NULL) {
97 if (CurrentToken->is(tok::greater)) {
98 Left->MatchingParen = CurrentToken;
99 CurrentToken->MatchingParen = Left;
100 CurrentToken->Type = TT_TemplateCloser;
101 next();
102 return true;
103 }
104 if (CurrentToken->is(tok::r_paren) || CurrentToken->is(tok::r_square) ||
105 CurrentToken->is(tok::r_brace))
106 return false;
107 if (CurrentToken->is(tok::pipepipe) || CurrentToken->is(tok::ampamp) ||
108 CurrentToken->is(tok::question) || CurrentToken->is(tok::colon))
109 return false;
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000110 updateParameterCount(Left, CurrentToken);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000111 if (!consumeToken())
112 return false;
113 }
114 return false;
115 }
116
117 bool parseParens(bool LookForDecls = false) {
118 if (CurrentToken == NULL)
119 return false;
Daniel Jasper4e778092013-02-06 10:05:46 +0000120 ScopedContextCreator ContextCreator(*this, 1);
121
122 // FIXME: This is a bit of a hack. Do better.
123 Contexts.back().ColonIsForRangeExpr =
124 Contexts.size() == 2 && Contexts[0].ColonIsForRangeExpr;
125
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000126 bool StartsObjCMethodExpr = false;
127 AnnotatedToken *Left = CurrentToken->Parent;
128 if (CurrentToken->is(tok::caret)) {
129 // ^( starts a block.
130 Left->Type = TT_ObjCBlockLParen;
131 } else if (AnnotatedToken *MaybeSel = Left->Parent) {
132 // @selector( starts a selector.
133 if (MaybeSel->isObjCAtKeyword(tok::objc_selector) && MaybeSel->Parent &&
134 MaybeSel->Parent->is(tok::at)) {
135 StartsObjCMethodExpr = true;
136 }
137 }
138
Daniel Jasper4e778092013-02-06 10:05:46 +0000139 if (StartsObjCMethodExpr) {
140 Contexts.back().ColonIsObjCMethodExpr = true;
141 Left->Type = TT_ObjCMethodExpr;
142 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000143
144 while (CurrentToken != NULL) {
145 // LookForDecls is set when "if (" has been seen. Check for
146 // 'identifier' '*' 'identifier' followed by not '=' -- this
147 // '*' has to be a binary operator but determineStarAmpUsage() will
148 // categorize it as an unary operator, so set the right type here.
149 if (LookForDecls && !CurrentToken->Children.empty()) {
150 AnnotatedToken &Prev = *CurrentToken->Parent;
151 AnnotatedToken &Next = CurrentToken->Children[0];
152 if (Prev.Parent->is(tok::identifier) &&
153 (Prev.is(tok::star) || Prev.is(tok::amp)) &&
154 CurrentToken->is(tok::identifier) && Next.isNot(tok::equal)) {
155 Prev.Type = TT_BinaryOperator;
156 LookForDecls = false;
157 }
158 }
159
160 if (CurrentToken->is(tok::r_paren)) {
161 Left->MatchingParen = CurrentToken;
162 CurrentToken->MatchingParen = Left;
163
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000164 if (StartsObjCMethodExpr) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000165 CurrentToken->Type = TT_ObjCMethodExpr;
166 if (Contexts.back().FirstObjCSelectorName != NULL) {
167 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
168 Contexts.back().LongestObjCSelectorName;
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000169 }
170 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000171
172 next();
173 return true;
174 }
175 if (CurrentToken->is(tok::r_square) || CurrentToken->is(tok::r_brace))
176 return false;
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000177 updateParameterCount(Left, CurrentToken);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000178 if (!consumeToken())
179 return false;
180 }
181 return false;
182 }
183
184 bool parseSquare() {
185 if (!CurrentToken)
186 return false;
Daniel Jasper4e778092013-02-06 10:05:46 +0000187 ScopedContextCreator ContextCreator(*this, 10);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000188
189 // A '[' could be an index subscript (after an indentifier or after
Nico Weber051860e2013-02-10 02:08:05 +0000190 // ')' or ']'), it could be the start of an Objective-C method
191 // expression, or it could the the start of an Objective-C array literal.
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000192 AnnotatedToken *Left = CurrentToken->Parent;
Nico Weber4ed7f3e2013-02-06 16:54:35 +0000193 AnnotatedToken *Parent = getPreviousToken(*Left);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000194 bool StartsObjCMethodExpr =
Nico Weber4ed7f3e2013-02-06 16:54:35 +0000195 !Parent || Parent->is(tok::colon) || Parent->is(tok::l_square) ||
196 Parent->is(tok::l_paren) || Parent->is(tok::kw_return) ||
197 Parent->is(tok::kw_throw) || isUnaryOperator(*Parent) ||
Nico Weber4c2cc602013-02-13 03:48:27 +0000198 Parent->Type == TT_ObjCForIn || Parent->Type == TT_CastRParen ||
Nico Weber4ed7f3e2013-02-06 16:54:35 +0000199 getBinOpPrecedence(Parent->FormatTok.Tok.getKind(), true, true) >
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000200 prec::Unknown;
Nico Weber051860e2013-02-10 02:08:05 +0000201 bool StartsObjCArrayLiteral = Parent && Parent->is(tok::at);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000202
Daniel Jasper4e778092013-02-06 10:05:46 +0000203 if (StartsObjCMethodExpr) {
204 Contexts.back().ColonIsObjCMethodExpr = true;
205 Left->Type = TT_ObjCMethodExpr;
Nico Weber051860e2013-02-10 02:08:05 +0000206 } else if (StartsObjCArrayLiteral) {
207 Left->Type = TT_ObjCArrayLiteral;
Daniel Jasper4e778092013-02-06 10:05:46 +0000208 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000209
210 while (CurrentToken != NULL) {
211 if (CurrentToken->is(tok::r_square)) {
212 if (!CurrentToken->Children.empty() &&
213 CurrentToken->Children[0].is(tok::l_paren)) {
Nico Webere8a97982013-02-06 06:20:11 +0000214 // An ObjC method call is rarely followed by an open parenthesis.
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000215 // FIXME: Do we incorrectly label ":" with this?
216 StartsObjCMethodExpr = false;
217 Left->Type = TT_Unknown;
218 }
Daniel Jasper01786732013-02-04 07:21:18 +0000219 if (StartsObjCMethodExpr) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000220 CurrentToken->Type = TT_ObjCMethodExpr;
Nico Webere8a97982013-02-06 06:20:11 +0000221 // determineStarAmpUsage() thinks that '*' '[' is allocating an
222 // array of pointers, but if '[' starts a selector then '*' is a
223 // binary operator.
Nico Weber4ed7f3e2013-02-06 16:54:35 +0000224 if (Parent != NULL &&
225 (Parent->is(tok::star) || Parent->is(tok::amp)) &&
226 Parent->Type == TT_PointerOrReference)
227 Parent->Type = TT_BinaryOperator;
Nico Weber051860e2013-02-10 02:08:05 +0000228 } else if (StartsObjCArrayLiteral) {
229 CurrentToken->Type = TT_ObjCArrayLiteral;
Daniel Jasper01786732013-02-04 07:21:18 +0000230 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000231 Left->MatchingParen = CurrentToken;
232 CurrentToken->MatchingParen = Left;
Daniel Jasper4e778092013-02-06 10:05:46 +0000233 if (Contexts.back().FirstObjCSelectorName != NULL)
234 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
235 Contexts.back().LongestObjCSelectorName;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000236 next();
237 return true;
238 }
239 if (CurrentToken->is(tok::r_paren) || CurrentToken->is(tok::r_brace))
240 return false;
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000241 updateParameterCount(Left, CurrentToken);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000242 if (!consumeToken())
243 return false;
244 }
245 return false;
246 }
247
248 bool parseBrace() {
249 // Lines are fine to end with '{'.
250 if (CurrentToken == NULL)
251 return true;
Daniel Jasper4e778092013-02-06 10:05:46 +0000252 ScopedContextCreator ContextCreator(*this, 1);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000253 AnnotatedToken *Left = CurrentToken->Parent;
254 while (CurrentToken != NULL) {
255 if (CurrentToken->is(tok::r_brace)) {
256 Left->MatchingParen = CurrentToken;
257 CurrentToken->MatchingParen = Left;
258 next();
259 return true;
260 }
261 if (CurrentToken->is(tok::r_paren) || CurrentToken->is(tok::r_square))
262 return false;
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000263 updateParameterCount(Left, CurrentToken);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000264 if (!consumeToken())
265 return false;
266 }
267 return true;
268 }
Daniel Jasperc4615b72013-02-20 12:56:39 +0000269
Daniel Jasper9fc56f22013-02-14 15:01:34 +0000270 void updateParameterCount(AnnotatedToken *Left, AnnotatedToken *Current) {
271 if (Current->is(tok::comma))
272 ++Left->ParameterCount;
273 else if (Left->ParameterCount == 0 && Current->isNot(tok::comment))
274 Left->ParameterCount = 1;
275 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000276
277 bool parseConditional() {
278 while (CurrentToken != NULL) {
279 if (CurrentToken->is(tok::colon)) {
280 CurrentToken->Type = TT_ConditionalExpr;
281 next();
282 return true;
283 }
284 if (!consumeToken())
285 return false;
286 }
287 return false;
288 }
289
290 bool parseTemplateDeclaration() {
291 if (CurrentToken != NULL && CurrentToken->is(tok::less)) {
292 CurrentToken->Type = TT_TemplateOpener;
293 next();
294 if (!parseAngle())
295 return false;
Daniel Jasper34511fb2013-02-19 17:14:38 +0000296 if (CurrentToken != NULL)
297 CurrentToken->Parent->ClosesTemplateDeclaration = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000298 return true;
299 }
300 return false;
301 }
302
303 bool consumeToken() {
304 AnnotatedToken *Tok = CurrentToken;
305 next();
306 switch (Tok->FormatTok.Tok.getKind()) {
307 case tok::plus:
308 case tok::minus:
309 // At the start of the line, +/- specific ObjectiveC method
310 // declarations.
311 if (Tok->Parent == NULL)
312 Tok->Type = TT_ObjCMethodSpecifier;
313 break;
314 case tok::colon:
315 // Colons from ?: are handled in parseConditional().
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000316 if (Tok->Parent->is(tok::r_paren)) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000317 Tok->Type = TT_CtorInitializerColon;
Daniel Jasper4e778092013-02-06 10:05:46 +0000318 } else if (Contexts.back().ColonIsObjCMethodExpr ||
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000319 Line.First.Type == TT_ObjCMethodSpecifier) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000320 Tok->Type = TT_ObjCMethodExpr;
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000321 Tok->Parent->Type = TT_ObjCSelectorName;
Daniel Jasper4e778092013-02-06 10:05:46 +0000322 if (Tok->Parent->FormatTok.TokenLength >
323 Contexts.back().LongestObjCSelectorName)
324 Contexts.back().LongestObjCSelectorName =
325 Tok->Parent->FormatTok.TokenLength;
326 if (Contexts.back().FirstObjCSelectorName == NULL)
327 Contexts.back().FirstObjCSelectorName = Tok->Parent;
328 } else if (Contexts.back().ColonIsForRangeExpr) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000329 Tok->Type = TT_RangeBasedForLoopColon;
Daniel Jasper6cabab42013-02-14 08:42:54 +0000330 } else if (Contexts.size() == 1) {
331 Tok->Type = TT_InheritanceColon;
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000332 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000333 break;
334 case tok::kw_if:
335 case tok::kw_while:
336 if (CurrentToken != NULL && CurrentToken->is(tok::l_paren)) {
337 next();
338 if (!parseParens(/*LookForDecls=*/ true))
339 return false;
340 }
341 break;
342 case tok::kw_for:
Daniel Jasper4e778092013-02-06 10:05:46 +0000343 Contexts.back().ColonIsForRangeExpr = true;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000344 next();
345 if (!parseParens())
346 return false;
347 break;
348 case tok::l_paren:
349 if (!parseParens())
350 return false;
351 break;
352 case tok::l_square:
353 if (!parseSquare())
354 return false;
355 break;
356 case tok::l_brace:
357 if (!parseBrace())
358 return false;
359 break;
360 case tok::less:
361 if (parseAngle())
362 Tok->Type = TT_TemplateOpener;
363 else {
364 Tok->Type = TT_BinaryOperator;
365 CurrentToken = Tok;
366 next();
367 }
368 break;
369 case tok::r_paren:
370 case tok::r_square:
371 return false;
372 case tok::r_brace:
373 // Lines can start with '}'.
374 if (Tok->Parent != NULL)
375 return false;
376 break;
377 case tok::greater:
378 Tok->Type = TT_BinaryOperator;
379 break;
380 case tok::kw_operator:
Daniel Jasper2b4c9242013-02-11 08:01:18 +0000381 while (CurrentToken && CurrentToken->isNot(tok::l_paren)) {
382 if (CurrentToken->is(tok::star) || CurrentToken->is(tok::amp))
383 CurrentToken->Type = TT_PointerOrReference;
384 consumeToken();
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000385 }
Daniel Jasper2b4c9242013-02-11 08:01:18 +0000386 if (CurrentToken)
387 CurrentToken->Type = TT_OverloadedOperatorLParen;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000388 break;
389 case tok::question:
390 parseConditional();
391 break;
392 case tok::kw_template:
393 parseTemplateDeclaration();
394 break;
Nico Weberc2e6d2a2013-02-11 15:32:15 +0000395 case tok::identifier:
396 if (Line.First.is(tok::kw_for) &&
397 Tok->FormatTok.Tok.getIdentifierInfo() == &Ident_in)
398 Tok->Type = TT_ObjCForIn;
399 break;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000400 default:
401 break;
402 }
403 return true;
404 }
405
406 void parseIncludeDirective() {
407 next();
408 if (CurrentToken != NULL && CurrentToken->is(tok::less)) {
409 next();
410 while (CurrentToken != NULL) {
411 if (CurrentToken->isNot(tok::comment) ||
412 !CurrentToken->Children.empty())
413 CurrentToken->Type = TT_ImplicitStringLiteral;
414 next();
415 }
416 } else {
417 while (CurrentToken != NULL) {
418 next();
419 }
420 }
421 }
422
423 void parseWarningOrError() {
424 next();
425 // We still want to format the whitespace left of the first token of the
426 // warning or error.
427 next();
428 while (CurrentToken != NULL) {
429 CurrentToken->Type = TT_ImplicitStringLiteral;
430 next();
431 }
432 }
433
434 void parsePreprocessorDirective() {
435 next();
436 if (CurrentToken == NULL)
437 return;
438 // Hashes in the middle of a line can lead to any strange token
439 // sequence.
440 if (CurrentToken->FormatTok.Tok.getIdentifierInfo() == NULL)
441 return;
442 switch (CurrentToken->FormatTok.Tok.getIdentifierInfo()->getPPKeywordID()) {
443 case tok::pp_include:
444 case tok::pp_import:
445 parseIncludeDirective();
446 break;
447 case tok::pp_error:
448 case tok::pp_warning:
449 parseWarningOrError();
450 break;
451 default:
452 break;
453 }
Daniel Jasper5b7e7b02013-02-05 09:34:14 +0000454 while (CurrentToken != NULL)
455 next();
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000456 }
457
Nico Weber95e8e462013-02-12 16:17:07 +0000458public:
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000459 LineType parseLine() {
460 int PeriodsAndArrows = 0;
461 bool CanBeBuilderTypeStmt = true;
462 if (CurrentToken->is(tok::hash)) {
463 parsePreprocessorDirective();
464 return LT_PreprocessorDirective;
465 }
466 while (CurrentToken != NULL) {
467 if (CurrentToken->is(tok::kw_virtual))
468 KeywordVirtualFound = true;
469 if (CurrentToken->is(tok::period) || CurrentToken->is(tok::arrow))
470 ++PeriodsAndArrows;
Daniel Jasper4a544e52013-02-15 20:33:06 +0000471 AnnotatedToken *TheToken = CurrentToken;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000472 if (!consumeToken())
473 return LT_Invalid;
Daniel Jasper4a544e52013-02-15 20:33:06 +0000474 if (getPrecedence(*TheToken) > prec::Assignment &&
Daniel Jasper82282dc2013-02-18 13:52:06 +0000475 TheToken->Type == TT_BinaryOperator)
Daniel Jasper4a544e52013-02-15 20:33:06 +0000476 CanBeBuilderTypeStmt = false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000477 }
478 if (KeywordVirtualFound)
479 return LT_VirtualFunctionDecl;
480
481 // Assume a builder-type call if there are 2 or more "." and "->".
482 if (PeriodsAndArrows >= 2 && CanBeBuilderTypeStmt)
483 return LT_BuilderTypeCall;
484
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000485 if (Line.First.Type == TT_ObjCMethodSpecifier) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000486 if (Contexts.back().FirstObjCSelectorName != NULL)
487 Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName =
488 Contexts.back().LongestObjCSelectorName;
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000489 return LT_ObjCMethodDecl;
490 }
491
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000492 return LT_Other;
493 }
494
Nico Weber95e8e462013-02-12 16:17:07 +0000495private:
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000496 void next() {
Daniel Jasper01786732013-02-04 07:21:18 +0000497 if (CurrentToken != NULL) {
498 determineTokenType(*CurrentToken);
Daniel Jasper4e778092013-02-06 10:05:46 +0000499 CurrentToken->BindingStrength = Contexts.back().BindingStrength;
Daniel Jasper01786732013-02-04 07:21:18 +0000500 }
501
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000502 if (CurrentToken != NULL && !CurrentToken->Children.empty())
503 CurrentToken = &CurrentToken->Children[0];
504 else
505 CurrentToken = NULL;
Daniel Jasperd0f349b2013-02-18 12:44:35 +0000506
507 // Reset token type in case we have already looked at it and then recovered
508 // from an error (e.g. failure to find the matching >).
509 if (CurrentToken != NULL)
510 CurrentToken->Type = TT_Unknown;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000511 }
512
Daniel Jasper4e778092013-02-06 10:05:46 +0000513 /// \brief A struct to hold information valid in a specific context, e.g.
514 /// a pair of parenthesis.
515 struct Context {
516 Context(unsigned BindingStrength, bool IsExpression)
517 : BindingStrength(BindingStrength), LongestObjCSelectorName(0),
518 ColonIsForRangeExpr(false), ColonIsObjCMethodExpr(false),
519 FirstObjCSelectorName(NULL), IsExpression(IsExpression),
Daniel Jasperf11a7052013-02-21 21:33:55 +0000520 LookForFunctionName(false) {}
Daniel Jasper01786732013-02-04 07:21:18 +0000521
Daniel Jasper4e778092013-02-06 10:05:46 +0000522 unsigned BindingStrength;
523 unsigned LongestObjCSelectorName;
524 bool ColonIsForRangeExpr;
525 bool ColonIsObjCMethodExpr;
526 AnnotatedToken *FirstObjCSelectorName;
527 bool IsExpression;
528 bool LookForFunctionName;
529 };
530
531 /// \brief Puts a new \c Context onto the stack \c Contexts for the lifetime
532 /// of each instance.
533 struct ScopedContextCreator {
534 AnnotatingParser &P;
535
Daniel Jasperfc759082013-02-14 14:26:07 +0000536 ScopedContextCreator(AnnotatingParser &P, unsigned Increase) : P(P) {
537 P.Contexts.push_back(Context(P.Contexts.back().BindingStrength + Increase,
538 P.Contexts.back().IsExpression));
Daniel Jasper4e778092013-02-06 10:05:46 +0000539 }
540
541 ~ScopedContextCreator() { P.Contexts.pop_back(); }
542 };
Daniel Jasper01786732013-02-04 07:21:18 +0000543
544 void determineTokenType(AnnotatedToken &Current) {
545 if (getPrecedence(Current) == prec::Assignment) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000546 Contexts.back().IsExpression = true;
Nico Weber95e8e462013-02-12 16:17:07 +0000547 for (AnnotatedToken *Previous = Current.Parent;
548 Previous && Previous->isNot(tok::comma);
549 Previous = Previous->Parent) {
Daniel Jasper01786732013-02-04 07:21:18 +0000550 if (Previous->Type == TT_BinaryOperator &&
551 (Previous->is(tok::star) || Previous->is(tok::amp))) {
552 Previous->Type = TT_PointerOrReference;
553 }
Daniel Jasper01786732013-02-04 07:21:18 +0000554 }
Nico Weber95e8e462013-02-12 16:17:07 +0000555 } else if (Current.is(tok::kw_return) || Current.is(tok::kw_throw) ||
556 (Current.is(tok::l_paren) && !Line.MustBeDeclaration &&
557 (!Current.Parent || Current.Parent->isNot(tok::kw_for)))) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000558 Contexts.back().IsExpression = true;
Nico Weber95e8e462013-02-12 16:17:07 +0000559 } else if (Current.is(tok::r_paren) || Current.is(tok::greater) ||
560 Current.is(tok::comma)) {
561 for (AnnotatedToken *Previous = Current.Parent;
562 Previous && (Previous->is(tok::star) || Previous->is(tok::amp));
563 Previous = Previous->Parent)
564 Previous->Type = TT_PointerOrReference;
Daniel Jasperd0f349b2013-02-18 12:44:35 +0000565 } else if (Current.Parent &&
566 Current.Parent->Type == TT_CtorInitializerColon) {
567 Contexts.back().IsExpression = true;
Nico Weber95e8e462013-02-12 16:17:07 +0000568 }
Daniel Jasper01786732013-02-04 07:21:18 +0000569
570 if (Current.Type == TT_Unknown) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000571 if (Contexts.back().LookForFunctionName && Current.is(tok::l_paren)) {
Daniel Jasper01786732013-02-04 07:21:18 +0000572 findFunctionName(&Current);
Daniel Jasper4e778092013-02-06 10:05:46 +0000573 Contexts.back().LookForFunctionName = false;
Daniel Jasper01786732013-02-04 07:21:18 +0000574 } else if (Current.is(tok::star) || Current.is(tok::amp)) {
Daniel Jasper4e778092013-02-06 10:05:46 +0000575 Current.Type =
576 determineStarAmpUsage(Current, Contexts.back().IsExpression);
Daniel Jasper01786732013-02-04 07:21:18 +0000577 } else if (Current.is(tok::minus) || Current.is(tok::plus) ||
578 Current.is(tok::caret)) {
579 Current.Type = determinePlusMinusCaretUsage(Current);
580 } else if (Current.is(tok::minusminus) || Current.is(tok::plusplus)) {
581 Current.Type = determineIncrementUsage(Current);
582 } else if (Current.is(tok::exclaim)) {
583 Current.Type = TT_UnaryOperator;
584 } else if (isBinaryOperator(Current)) {
585 Current.Type = TT_BinaryOperator;
586 } else if (Current.is(tok::comment)) {
587 std::string Data(Lexer::getSpelling(Current.FormatTok.Tok, SourceMgr,
588 Lex.getLangOpts()));
589 if (StringRef(Data).startswith("//"))
590 Current.Type = TT_LineComment;
591 else
592 Current.Type = TT_BlockComment;
Nico Weber37d69312013-02-13 04:13:13 +0000593 } else if (Current.is(tok::r_paren)) {
Daniel Jasper03628b82013-02-19 20:05:41 +0000594 bool ParensNotExpr = !Current.Parent ||
595 Current.Parent->Type == TT_PointerOrReference ||
Nico Weber37d69312013-02-13 04:13:13 +0000596 Current.Parent->Type == TT_TemplateCloser;
597 bool ParensCouldEndDecl =
598 !Current.Children.empty() && (Current.Children[0].is(tok::equal) ||
599 Current.Children[0].is(tok::semi) ||
600 Current.Children[0].is(tok::l_brace));
601 if (ParensNotExpr && !ParensCouldEndDecl)
602 // FIXME: We need to get smarter and understand more cases of casts.
603 Current.Type = TT_CastRParen;
Daniel Jasper01786732013-02-04 07:21:18 +0000604 } else if (Current.is(tok::at) && Current.Children.size()) {
605 switch (Current.Children[0].FormatTok.Tok.getObjCKeywordID()) {
606 case tok::objc_interface:
607 case tok::objc_implementation:
608 case tok::objc_protocol:
609 Current.Type = TT_ObjCDecl;
610 break;
611 case tok::objc_property:
612 Current.Type = TT_ObjCProperty;
613 break;
614 default:
615 break;
616 }
617 }
618 }
619 }
620
621 /// \brief Starting from \p Current, this searches backwards for an
622 /// identifier which could be the start of a function name and marks it.
623 void findFunctionName(AnnotatedToken *Current) {
624 AnnotatedToken *Parent = Current->Parent;
625 while (Parent != NULL && Parent->Parent != NULL) {
626 if (Parent->is(tok::identifier) &&
627 (Parent->Parent->is(tok::identifier) ||
628 Parent->Parent->Type == TT_PointerOrReference ||
629 Parent->Parent->Type == TT_TemplateCloser)) {
630 Parent->Type = TT_StartOfName;
631 break;
632 }
633 Parent = Parent->Parent;
634 }
635 }
636
637 /// \brief Return the type of the given token assuming it is * or &.
638 TokenType
639 determineStarAmpUsage(const AnnotatedToken &Tok, bool IsExpression) {
640 const AnnotatedToken *PrevToken = getPreviousToken(Tok);
641 if (PrevToken == NULL)
642 return TT_UnaryOperator;
643
644 const AnnotatedToken *NextToken = getNextToken(Tok);
645 if (NextToken == NULL)
646 return TT_Unknown;
647
Daniel Jasper01786732013-02-04 07:21:18 +0000648 if (PrevToken->is(tok::l_paren) || PrevToken->is(tok::l_square) ||
649 PrevToken->is(tok::l_brace) || PrevToken->is(tok::comma) ||
650 PrevToken->is(tok::kw_return) || PrevToken->is(tok::colon) ||
Nico Webere8a97982013-02-06 06:20:11 +0000651 PrevToken->is(tok::equal) || PrevToken->Type == TT_BinaryOperator ||
Daniel Jasper01786732013-02-04 07:21:18 +0000652 PrevToken->Type == TT_UnaryOperator || PrevToken->Type == TT_CastRParen)
653 return TT_UnaryOperator;
654
Nico Webere8a97982013-02-06 06:20:11 +0000655 if (NextToken->is(tok::l_square))
656 return TT_PointerOrReference;
657
Daniel Jasper01786732013-02-04 07:21:18 +0000658 if (PrevToken->FormatTok.Tok.isLiteral() || PrevToken->is(tok::r_paren) ||
659 PrevToken->is(tok::r_square) || NextToken->FormatTok.Tok.isLiteral() ||
Nico Weberee0feec2013-02-05 16:21:00 +0000660 isUnaryOperator(*NextToken) || NextToken->is(tok::l_paren) ||
661 NextToken->is(tok::l_square))
Daniel Jasper01786732013-02-04 07:21:18 +0000662 return TT_BinaryOperator;
663
Daniel Jasper01786732013-02-04 07:21:18 +0000664 // It is very unlikely that we are going to find a pointer or reference type
665 // definition on the RHS of an assignment.
666 if (IsExpression)
667 return TT_BinaryOperator;
668
669 return TT_PointerOrReference;
670 }
671
672 TokenType determinePlusMinusCaretUsage(const AnnotatedToken &Tok) {
673 const AnnotatedToken *PrevToken = getPreviousToken(Tok);
674 if (PrevToken == NULL)
675 return TT_UnaryOperator;
676
677 // Use heuristics to recognize unary operators.
678 if (PrevToken->is(tok::equal) || PrevToken->is(tok::l_paren) ||
679 PrevToken->is(tok::comma) || PrevToken->is(tok::l_square) ||
680 PrevToken->is(tok::question) || PrevToken->is(tok::colon) ||
681 PrevToken->is(tok::kw_return) || PrevToken->is(tok::kw_case) ||
682 PrevToken->is(tok::at) || PrevToken->is(tok::l_brace))
683 return TT_UnaryOperator;
684
Nico Weberee0feec2013-02-05 16:21:00 +0000685 // There can't be two consecutive binary operators.
Daniel Jasper01786732013-02-04 07:21:18 +0000686 if (PrevToken->Type == TT_BinaryOperator)
687 return TT_UnaryOperator;
688
689 // Fall back to marking the token as binary operator.
690 return TT_BinaryOperator;
691 }
692
693 /// \brief Determine whether ++/-- are pre- or post-increments/-decrements.
694 TokenType determineIncrementUsage(const AnnotatedToken &Tok) {
695 const AnnotatedToken *PrevToken = getPreviousToken(Tok);
696 if (PrevToken == NULL)
697 return TT_UnaryOperator;
698 if (PrevToken->is(tok::r_paren) || PrevToken->is(tok::r_square) ||
699 PrevToken->is(tok::identifier))
700 return TT_TrailingUnaryOperator;
701
702 return TT_UnaryOperator;
703 }
Daniel Jasper4e778092013-02-06 10:05:46 +0000704
705 SmallVector<Context, 8> Contexts;
706
707 SourceManager &SourceMgr;
708 Lexer &Lex;
709 AnnotatedLine &Line;
710 AnnotatedToken *CurrentToken;
711 bool KeywordVirtualFound;
Nico Weberc2e6d2a2013-02-11 15:32:15 +0000712 IdentifierInfo &Ident_in;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000713};
714
Daniel Jasper29f123b2013-02-08 15:28:42 +0000715/// \brief Parses binary expressions by inserting fake parenthesis based on
716/// operator precedence.
717class ExpressionParser {
718public:
719 ExpressionParser(AnnotatedLine &Line) : Current(&Line.First) {}
720
721 /// \brief Parse expressions with the given operatore precedence.
Dmitri Gribenko6ba52aa2013-02-16 20:03:26 +0000722 void parse(prec::Level Precedence = prec::Unknown) {
Daniel Jasper29f123b2013-02-08 15:28:42 +0000723 if (Precedence > prec::PointerToMember || Current == NULL)
724 return;
725
726 // Skip over "return" until we can properly parse it.
727 if (Current->is(tok::kw_return))
728 next();
729
730 // Eagerly consume trailing comments.
731 while (isTrailingComment(Current)) {
732 next();
733 }
734
735 AnnotatedToken *Start = Current;
736 bool OperatorFound = false;
737
738 while (Current != NULL) {
739 // Consume operators with higher precedence.
Dmitri Gribenko6ba52aa2013-02-16 20:03:26 +0000740 parse(prec::Level(Precedence + 1));
Daniel Jasper29f123b2013-02-08 15:28:42 +0000741
742 // At the end of the line or when an operator with higher precedence is
743 // found, insert fake parenthesis and return.
744 if (Current == NULL || Current->is(tok::semi) || closesScope(*Current) ||
745 ((Current->Type == TT_BinaryOperator || Current->is(tok::comma)) &&
Aaron Ballman468e3992013-02-12 19:20:48 +0000746 getPrecedence(*Current) < Precedence)) {
Daniel Jasper29f123b2013-02-08 15:28:42 +0000747 if (OperatorFound) {
748 ++Start->FakeLParens;
749 if (Current != NULL)
Daniel Jasper087387a2013-02-08 16:49:27 +0000750 ++Current->Parent->FakeRParens;
Daniel Jasper29f123b2013-02-08 15:28:42 +0000751 }
752 return;
753 }
754
755 // Consume scopes: (), [], <> and {}
756 if (opensScope(*Current)) {
757 while (Current != NULL && !closesScope(*Current)) {
758 next();
759 parse();
760 }
761 next();
762 } else {
763 // Operator found.
764 if (getPrecedence(*Current) == Precedence)
765 OperatorFound = true;
766
767 next();
768 }
769 }
770 }
771
772private:
773 void next() {
774 if (Current != NULL)
775 Current = Current->Children.empty() ? NULL : &Current->Children[0];
776 }
777
778 bool closesScope(const AnnotatedToken &Tok) {
779 return Current->is(tok::r_paren) || Current->Type == TT_TemplateCloser ||
780 Current->is(tok::r_brace) || Current->is(tok::r_square);
781 }
782
783 bool opensScope(const AnnotatedToken &Tok) {
784 return Current->is(tok::l_paren) || Current->Type == TT_TemplateOpener ||
785 Current->is(tok::l_brace) || Current->is(tok::l_square);
786 }
787
788 AnnotatedToken *Current;
789};
790
Daniel Jasper8ff690a2013-02-06 14:22:40 +0000791void TokenAnnotator::annotate(AnnotatedLine &Line) {
Nico Weberc2e6d2a2013-02-11 15:32:15 +0000792 AnnotatingParser Parser(SourceMgr, Lex, Line, Ident_in);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000793 Line.Type = Parser.parseLine();
794 if (Line.Type == LT_Invalid)
795 return;
796
Daniel Jasper29f123b2013-02-08 15:28:42 +0000797 ExpressionParser ExprParser(Line);
798 ExprParser.parse();
799
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000800 if (Line.First.Type == TT_ObjCMethodSpecifier)
801 Line.Type = LT_ObjCMethodDecl;
802 else if (Line.First.Type == TT_ObjCDecl)
803 Line.Type = LT_ObjCDecl;
804 else if (Line.First.Type == TT_ObjCProperty)
805 Line.Type = LT_ObjCProperty;
806
Daniel Jasper729a7432013-02-11 12:36:37 +0000807 Line.First.SpacesRequiredBefore = 1;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000808 Line.First.MustBreakBefore = Line.First.FormatTok.MustBreakBefore;
809 Line.First.CanBreakBefore = Line.First.MustBreakBefore;
810
811 Line.First.TotalLength = Line.First.FormatTok.TokenLength;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000812}
813
Daniel Jasper8ff690a2013-02-06 14:22:40 +0000814void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) {
815 if (Line.First.Children.empty())
816 return;
817 AnnotatedToken *Current = &Line.First.Children[0];
818 while (Current != NULL) {
Daniel Jasper729a7432013-02-11 12:36:37 +0000819 if (Current->Type == TT_LineComment)
820 Current->SpacesRequiredBefore = Style.SpacesBeforeTrailingComments;
821 else
822 Current->SpacesRequiredBefore =
823 spaceRequiredBefore(Line, *Current) ? 1 : 0;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000824
Daniel Jasper8ff690a2013-02-06 14:22:40 +0000825 if (Current->FormatTok.MustBreakBefore) {
826 Current->MustBreakBefore = true;
827 } else if (Current->Type == TT_LineComment) {
828 Current->MustBreakBefore = Current->FormatTok.NewlinesBefore > 0;
Daniel Jasper29f123b2013-02-08 15:28:42 +0000829 } else if (isTrailingComment(Current->Parent) ||
Daniel Jasper8ff690a2013-02-06 14:22:40 +0000830 (Current->is(tok::string_literal) &&
831 Current->Parent->is(tok::string_literal))) {
832 Current->MustBreakBefore = true;
833 } else if (Current->is(tok::lessless) && !Current->Children.empty() &&
834 Current->Parent->is(tok::string_literal) &&
835 Current->Children[0].is(tok::string_literal)) {
836 Current->MustBreakBefore = true;
Daniel Jasperc4615b72013-02-20 12:56:39 +0000837 } else if (Current->FormatTok.NewlinesBefore > 1) {
838 Current->MustBreakBefore = true;
Daniel Jasper8ff690a2013-02-06 14:22:40 +0000839 } else {
840 Current->MustBreakBefore = false;
841 }
842 Current->CanBreakBefore =
843 Current->MustBreakBefore || canBreakBefore(Line, *Current);
844 if (Current->MustBreakBefore)
845 Current->TotalLength = Current->Parent->TotalLength + Style.ColumnLimit;
846 else
847 Current->TotalLength =
848 Current->Parent->TotalLength + Current->FormatTok.TokenLength +
Daniel Jasper729a7432013-02-11 12:36:37 +0000849 Current->SpacesRequiredBefore;
Daniel Jasper8ff690a2013-02-06 14:22:40 +0000850 // FIXME: Only calculate this if CanBreakBefore is true once static
851 // initializers etc. are sorted out.
852 // FIXME: Move magic numbers to a better place.
853 Current->SplitPenalty =
854 20 * Current->BindingStrength + splitPenalty(Line, *Current);
855
856 Current = Current->Children.empty() ? NULL : &Current->Children[0];
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000857 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000858}
859
Daniel Jasper8ff690a2013-02-06 14:22:40 +0000860unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line,
861 const AnnotatedToken &Tok) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000862 const AnnotatedToken &Left = *Tok.Parent;
863 const AnnotatedToken &Right = Tok;
864
Daniel Jaspera03ab102013-02-13 20:33:44 +0000865 if (Right.Type == TT_StartOfName)
866 return Style.PenaltyReturnTypeOnItsOwnLine;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000867 if (Left.is(tok::l_brace) && Right.isNot(tok::l_brace))
868 return 50;
869 if (Left.is(tok::equal) && Right.is(tok::l_brace))
870 return 150;
871 if (Left.is(tok::coloncolon))
872 return 500;
873
Daniel Jasper6cabab42013-02-14 08:42:54 +0000874 if (Left.Type == TT_RangeBasedForLoopColon ||
875 Left.Type == TT_InheritanceColon)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000876 return 5;
877
878 if (Right.is(tok::arrow) || Right.is(tok::period)) {
Daniel Jasper515f65d2013-02-18 13:24:21 +0000879 if (Line.Type == LT_BuilderTypeCall)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000880 return 5; // Should be smaller than breaking at a nested comma.
Daniel Jasperfc759082013-02-14 14:26:07 +0000881 if ((Left.is(tok::r_paren) || Left.is(tok::r_square)) &&
882 Left.MatchingParen && Left.MatchingParen->ParameterCount > 0)
883 return 10;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000884 return 150;
885 }
886
887 // In for-loops, prefer breaking at ',' and ';'.
Daniel Jasper7d812812013-02-21 15:00:29 +0000888 if (Line.First.is(tok::kw_for) && Left.is(tok::equal))
889 return 4;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000890
Daniel Jasper8159d2f2013-02-04 07:30:30 +0000891 if (Left.is(tok::semi))
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000892 return 0;
Daniel Jasper8159d2f2013-02-04 07:30:30 +0000893 if (Left.is(tok::comma))
894 return 1;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000895
896 // In Objective-C method expressions, prefer breaking before "param:" over
897 // breaking after it.
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000898 if (Right.Type == TT_ObjCSelectorName)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000899 return 0;
Daniel Jasper63d7ced2013-02-05 10:07:47 +0000900 if (Left.is(tok::colon) && Left.Type == TT_ObjCMethodExpr)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000901 return 20;
902
Daniel Jasper01786732013-02-04 07:21:18 +0000903 if (Left.is(tok::l_paren) || Left.is(tok::l_square) ||
904 Left.Type == TT_TemplateOpener)
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000905 return 20;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000906
Daniel Jasper4e8a7b42013-02-06 21:04:05 +0000907 if (Right.is(tok::lessless)) {
908 if (Left.is(tok::string_literal)) {
909 char LastChar =
910 StringRef(Left.FormatTok.Tok.getLiteralData(),
911 Left.FormatTok.TokenLength).drop_back(1).rtrim().back();
912 if (LastChar == ':' || LastChar == '=')
913 return 100;
914 }
Daniel Jasper01786732013-02-04 07:21:18 +0000915 return prec::Shift;
Daniel Jasper4e8a7b42013-02-06 21:04:05 +0000916 }
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000917 if (Left.Type == TT_ConditionalExpr)
918 return prec::Assignment;
919 prec::Level Level = getPrecedence(Left);
920
921 if (Level != prec::Unknown)
922 return Level;
923
924 return 3;
925}
926
Daniel Jasper8ff690a2013-02-06 14:22:40 +0000927bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
928 const AnnotatedToken &Left,
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000929 const AnnotatedToken &Right) {
930 if (Right.is(tok::hashhash))
931 return Left.is(tok::hash);
932 if (Left.is(tok::hashhash) || Left.is(tok::hash))
933 return Right.is(tok::hash);
934 if (Right.is(tok::r_paren) || Right.is(tok::semi) || Right.is(tok::comma))
935 return false;
936 if (Right.is(tok::less) &&
937 (Left.is(tok::kw_template) ||
938 (Line.Type == LT_ObjCDecl && Style.ObjCSpaceBeforeProtocolList)))
939 return true;
940 if (Left.is(tok::arrow) || Right.is(tok::arrow))
941 return false;
942 if (Left.is(tok::exclaim) || Left.is(tok::tilde))
943 return false;
944 if (Left.is(tok::at) &&
945 (Right.is(tok::identifier) || Right.is(tok::string_literal) ||
946 Right.is(tok::char_constant) || Right.is(tok::numeric_constant) ||
947 Right.is(tok::l_paren) || Right.is(tok::l_brace) ||
948 Right.is(tok::kw_true) || Right.is(tok::kw_false)))
949 return false;
950 if (Left.is(tok::coloncolon))
951 return false;
952 if (Right.is(tok::coloncolon))
Daniel Jasperdaf1a152013-02-07 21:08:36 +0000953 return Left.isNot(tok::identifier) && Left.isNot(tok::greater) &&
954 Left.isNot(tok::l_paren);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000955 if (Left.is(tok::less) || Right.is(tok::greater) || Right.is(tok::less))
956 return false;
957 if (Right.is(tok::amp) || Right.is(tok::star))
958 return Left.FormatTok.Tok.isLiteral() ||
959 (Left.isNot(tok::star) && Left.isNot(tok::amp) &&
Nico Weber95e8e462013-02-12 16:17:07 +0000960 Left.isNot(tok::l_paren) && !Style.PointerBindsToType);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000961 if (Left.is(tok::amp) || Left.is(tok::star))
Nico Weber95e8e462013-02-12 16:17:07 +0000962 return Right.FormatTok.Tok.isLiteral() ||
963 (Right.isNot(tok::star) && Right.isNot(tok::amp) &&
964 Style.PointerBindsToType);
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000965 if (Right.is(tok::star) && Left.is(tok::l_paren))
966 return false;
Nico Weber051860e2013-02-10 02:08:05 +0000967 if (Left.is(tok::l_square))
968 return Left.Type == TT_ObjCArrayLiteral && Right.isNot(tok::r_square);
969 if (Right.is(tok::r_square))
970 return Right.Type == TT_ObjCArrayLiteral;
Daniel Jasper32d28ee2013-01-29 21:01:14 +0000971 if (Right.is(tok::l_square) && Right.Type != TT_ObjCMethodExpr)
972 return false;
973 if (Left.is(tok::period) || Right.is(tok::period))
974 return false;
975 if (Left.is(tok::colon))
976 return Left.Type != TT_ObjCMethodExpr;
977 if (Right.is(tok::colon))
978 return Right.Type != TT_ObjCMethodExpr;
979 if (Left.is(tok::l_paren))
980 return false;
981 if (Right.is(tok::l_paren)) {
982 return Line.Type == LT_ObjCDecl || Left.is(tok::kw_if) ||
983 Left.is(tok::kw_for) || Left.is(tok::kw_while) ||
984 Left.is(tok::kw_switch) || Left.is(tok::kw_return) ||
985 Left.is(tok::kw_catch) || Left.is(tok::kw_new) ||
986 Left.is(tok::kw_delete);
987 }
988 if (Left.is(tok::at) &&
989 Right.FormatTok.Tok.getObjCKeywordID() != tok::objc_not_keyword)
990 return false;
991 if (Left.is(tok::l_brace) && Right.is(tok::r_brace))
992 return false;
993 return true;
994}
995
Daniel Jasper8ff690a2013-02-06 14:22:40 +0000996bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line,
997 const AnnotatedToken &Tok) {
Daniel Jasper2b4c9242013-02-11 08:01:18 +0000998 if (Tok.FormatTok.Tok.getIdentifierInfo() &&
999 Tok.Parent->FormatTok.Tok.getIdentifierInfo())
1000 return true; // Never ever merge two identifiers.
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001001 if (Line.Type == LT_ObjCMethodDecl) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001002 if (Tok.Parent->Type == TT_ObjCMethodSpecifier)
1003 return true;
1004 if (Tok.Parent->is(tok::r_paren) && Tok.is(tok::identifier))
1005 // Don't space between ')' and <id>
1006 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001007 }
1008 if (Line.Type == LT_ObjCProperty &&
1009 (Tok.is(tok::equal) || Tok.Parent->is(tok::equal)))
1010 return false;
1011
1012 if (Tok.Parent->is(tok::comma))
1013 return true;
1014 if (Tok.Type == TT_CtorInitializerColon || Tok.Type == TT_ObjCBlockLParen)
1015 return true;
Daniel Jasper2b4c9242013-02-11 08:01:18 +00001016 if (Tok.Parent->FormatTok.Tok.is(tok::kw_operator))
1017 return false;
1018 if (Tok.Type == TT_OverloadedOperatorLParen)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001019 return false;
1020 if (Tok.is(tok::colon))
1021 return Line.First.isNot(tok::kw_case) && !Tok.Children.empty() &&
1022 Tok.Type != TT_ObjCMethodExpr;
1023 if (Tok.Parent->Type == TT_UnaryOperator || Tok.Parent->Type == TT_CastRParen)
1024 return false;
1025 if (Tok.Type == TT_UnaryOperator)
1026 return Tok.Parent->isNot(tok::l_paren) &&
1027 Tok.Parent->isNot(tok::l_square) && Tok.Parent->isNot(tok::at) &&
1028 (Tok.Parent->isNot(tok::colon) ||
1029 Tok.Parent->Type != TT_ObjCMethodExpr);
1030 if (Tok.Parent->is(tok::greater) && Tok.is(tok::greater)) {
Daniel Jasper29f123b2013-02-08 15:28:42 +00001031 return Tok.Type == TT_TemplateCloser &&
1032 Tok.Parent->Type == TT_TemplateCloser &&
1033 Style.Standard != FormatStyle::LS_Cpp11;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001034 }
1035 if (Tok.Type == TT_BinaryOperator || Tok.Parent->Type == TT_BinaryOperator)
1036 return true;
1037 if (Tok.Parent->Type == TT_TemplateCloser && Tok.is(tok::l_paren))
1038 return false;
1039 if (Tok.is(tok::less) && Line.First.is(tok::hash))
1040 return true;
1041 if (Tok.Type == TT_TrailingUnaryOperator)
1042 return false;
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001043 return spaceRequiredBetween(Line, *Tok.Parent, Tok);
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001044}
1045
Daniel Jasper8ff690a2013-02-06 14:22:40 +00001046bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line,
1047 const AnnotatedToken &Right) {
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001048 const AnnotatedToken &Left = *Right.Parent;
Daniel Jaspera03ab102013-02-13 20:33:44 +00001049 if (Right.Type == TT_StartOfName)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001050 return true;
1051 if (Right.is(tok::colon) && Right.Type == TT_ObjCMethodExpr)
1052 return false;
1053 if (Left.is(tok::colon) && Left.Type == TT_ObjCMethodExpr)
1054 return true;
Daniel Jasper63d7ced2013-02-05 10:07:47 +00001055 if (Right.Type == TT_ObjCSelectorName)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001056 return true;
1057 if (Left.ClosesTemplateDeclaration)
1058 return true;
1059 if (Right.Type == TT_ConditionalExpr || Right.is(tok::question))
1060 return true;
Daniel Jasper6cabab42013-02-14 08:42:54 +00001061 if (Right.Type == TT_RangeBasedForLoopColon ||
1062 Right.Type == TT_InheritanceColon)
1063 return false;
1064 if (Left.Type == TT_RangeBasedForLoopColon ||
1065 Left.Type == TT_InheritanceColon)
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001066 return true;
Daniel Jasper7d812812013-02-21 15:00:29 +00001067 if (Right.Type == TT_RangeBasedForLoopColon)
1068 return false;
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001069 if (Left.Type == TT_PointerOrReference || Left.Type == TT_TemplateCloser ||
1070 Left.Type == TT_UnaryOperator || Left.Type == TT_ConditionalExpr ||
Daniel Jasperdc2efa12013-02-15 19:24:08 +00001071 Left.is(tok::question) || Left.is(tok::kw_operator))
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001072 return false;
1073 if (Left.is(tok::equal) && Line.Type == LT_VirtualFunctionDecl)
1074 return false;
1075
1076 if (Right.Type == TT_LineComment)
1077 // We rely on MustBreakBefore being set correctly here as we should not
1078 // change the "binding" behavior of a comment.
1079 return false;
1080
Daniel Jasper7d812812013-02-21 15:00:29 +00001081 // FIXME: We can probably remove this special case once we have implemented
1082 // breaking after types in general.
1083 if (Line.First.is(tok::kw_for) && !Right.Children.empty() &&
1084 Right.Children[0].is(tok::equal))
1085 return true;
1086
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001087 // Allow breaking after a trailing 'const', e.g. after a method declaration,
1088 // unless it is follow by ';', '{' or '='.
1089 if (Left.is(tok::kw_const) && Left.Parent != NULL &&
1090 Left.Parent->is(tok::r_paren))
1091 return Right.isNot(tok::l_brace) && Right.isNot(tok::semi) &&
1092 Right.isNot(tok::equal);
1093
1094 // We only break before r_brace if there was a corresponding break before
1095 // the l_brace, which is tracked by BreakBeforeClosingBrace.
1096 if (Right.is(tok::r_brace))
1097 return false;
1098
1099 if (Right.is(tok::r_paren) || Right.is(tok::greater))
1100 return false;
1101 return (isBinaryOperator(Left) && Left.isNot(tok::lessless)) ||
1102 Left.is(tok::comma) || Right.is(tok::lessless) ||
1103 Right.is(tok::arrow) || Right.is(tok::period) ||
1104 Right.is(tok::colon) || Left.is(tok::coloncolon) ||
1105 Left.is(tok::semi) || Left.is(tok::l_brace) ||
Daniel Jasper32d28ee2013-01-29 21:01:14 +00001106 (Left.is(tok::r_paren) && Left.Type != TT_CastRParen &&
1107 Right.is(tok::identifier)) ||
1108 (Left.is(tok::l_paren) && !Right.is(tok::r_paren)) ||
1109 (Left.is(tok::l_square) && !Right.is(tok::r_square));
1110}
1111
1112} // namespace format
1113} // namespace clang