Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1 | //===--- 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 Jasper | bf71ba2 | 2013-04-08 20:33:42 +0000 | [diff] [blame] | 18 | #include "llvm/Support/Debug.h" |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 19 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 20 | #define DEBUG_TYPE "format-token-annotator" |
| 21 | |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 22 | namespace clang { |
| 23 | namespace format { |
| 24 | |
Craig Topper | 14e6649 | 2013-07-01 04:03:19 +0000 | [diff] [blame] | 25 | namespace { |
| 26 | |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 27 | /// \brief A parser that gathers additional information about tokens. |
| 28 | /// |
Alexander Kornienko | 3fd9ccd | 2013-03-12 16:28:18 +0000 | [diff] [blame] | 29 | /// The \c TokenAnnotator tries to match parenthesis and square brakets and |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 30 | /// store a parenthesis levels. It also tries to resolve matching "<" and ">" |
| 31 | /// into template parameter lists. |
| 32 | class AnnotatingParser { |
| 33 | public: |
Daniel Jasper | d4a03db | 2013-08-22 15:00:41 +0000 | [diff] [blame] | 34 | AnnotatingParser(const FormatStyle &Style, AnnotatedLine &Line, |
| 35 | IdentifierInfo &Ident_in) |
| 36 | : Style(Style), Line(Line), CurrentToken(Line.First), |
Daniel Jasper | 59875ac | 2013-11-07 17:43:07 +0000 | [diff] [blame] | 37 | KeywordVirtualFound(false), AutoFound(false), Ident_in(Ident_in) { |
Nico Weber | 2726877 | 2013-06-26 00:30:14 +0000 | [diff] [blame] | 38 | Contexts.push_back(Context(tok::unknown, 1, /*IsExpression=*/false)); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 39 | resetTokenMetadata(CurrentToken); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 40 | } |
| 41 | |
Nico Weber | 95e8e46 | 2013-02-12 16:17:07 +0000 | [diff] [blame] | 42 | private: |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 43 | bool parseAngle() { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 44 | if (!CurrentToken) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 45 | return false; |
Daniel Jasper | 923ebef | 2013-03-14 13:45:21 +0000 | [diff] [blame] | 46 | ScopedContextCreator ContextCreator(*this, tok::less, 10); |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 47 | FormatToken *Left = CurrentToken->Previous; |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 48 | Contexts.back().IsExpression = false; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 49 | // If there's a template keyword before the opening angle bracket, this is a |
| 50 | // template parameter, not an argument. |
| 51 | Contexts.back().InTemplateArgument = |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 52 | Left->Previous && Left->Previous->Tok.isNot(tok::kw_template); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 53 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 54 | while (CurrentToken) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 55 | if (CurrentToken->is(tok::greater)) { |
| 56 | Left->MatchingParen = CurrentToken; |
| 57 | CurrentToken->MatchingParen = Left; |
| 58 | CurrentToken->Type = TT_TemplateCloser; |
| 59 | next(); |
| 60 | return true; |
| 61 | } |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 62 | if (CurrentToken->isOneOf(tok::r_paren, tok::r_square, tok::r_brace, |
Daniel Jasper | 5d823e3 | 2013-05-15 13:46:48 +0000 | [diff] [blame] | 63 | tok::question, tok::colon)) |
| 64 | return false; |
Daniel Jasper | 0348be0 | 2013-06-01 18:56:00 +0000 | [diff] [blame] | 65 | // If a && or || is found and interpreted as a binary operator, this set |
Daniel Jasper | 15f33f0 | 2013-06-03 16:16:41 +0000 | [diff] [blame] | 66 | // of angles is likely part of something like "a < b && c > d". If the |
Daniel Jasper | 0348be0 | 2013-06-01 18:56:00 +0000 | [diff] [blame] | 67 | // angles are inside an expression, the ||/&& might also be a binary |
| 68 | // operator that was misinterpreted because we are parsing template |
| 69 | // parameters. |
| 70 | // FIXME: This is getting out of hand, write a decent parser. |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 71 | if (CurrentToken->Previous->isOneOf(tok::pipepipe, tok::ampamp) && |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 72 | ((CurrentToken->Previous->Type == TT_BinaryOperator && |
| 73 | // Toplevel bool expressions do not make lots of sense; |
| 74 | // If we're on the top level, it contains only the base context and |
| 75 | // the context for the current opening angle bracket. |
| 76 | Contexts.size() > 2) || |
Daniel Jasper | 0348be0 | 2013-06-01 18:56:00 +0000 | [diff] [blame] | 77 | Contexts[Contexts.size() - 2].IsExpression) && |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 78 | Line.First->isNot(tok::kw_template)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 79 | return false; |
Daniel Jasper | 9fc56f2 | 2013-02-14 15:01:34 +0000 | [diff] [blame] | 80 | updateParameterCount(Left, CurrentToken); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 81 | if (!consumeToken()) |
| 82 | return false; |
| 83 | } |
| 84 | return false; |
| 85 | } |
| 86 | |
| 87 | bool parseParens(bool LookForDecls = false) { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 88 | if (!CurrentToken) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 89 | return false; |
Daniel Jasper | 923ebef | 2013-03-14 13:45:21 +0000 | [diff] [blame] | 90 | ScopedContextCreator ContextCreator(*this, tok::l_paren, 1); |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 91 | |
| 92 | // FIXME: This is a bit of a hack. Do better. |
| 93 | Contexts.back().ColonIsForRangeExpr = |
| 94 | Contexts.size() == 2 && Contexts[0].ColonIsForRangeExpr; |
| 95 | |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 96 | bool StartsObjCMethodExpr = false; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 97 | FormatToken *Left = CurrentToken->Previous; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 98 | if (CurrentToken->is(tok::caret)) { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 99 | // (^ can start a block type. |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 100 | Left->Type = TT_ObjCBlockLParen; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 101 | } else if (FormatToken *MaybeSel = Left->Previous) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 102 | // @selector( starts a selector. |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 103 | if (MaybeSel->isObjCAtKeyword(tok::objc_selector) && MaybeSel->Previous && |
| 104 | MaybeSel->Previous->is(tok::at)) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 105 | StartsObjCMethodExpr = true; |
| 106 | } |
| 107 | } |
| 108 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 109 | if (Left->Previous && |
| 110 | (Left->Previous->isOneOf(tok::kw_static_assert, tok::kw_if, |
| 111 | tok::kw_while, tok::l_paren, tok::comma) || |
| 112 | Left->Previous->Type == TT_BinaryOperator)) { |
Daniel Jasper | 363193b | 2013-10-20 18:15:30 +0000 | [diff] [blame] | 113 | // static_assert, if and while usually contain expressions. |
Daniel Jasper | b7000ca | 2013-08-01 17:58:23 +0000 | [diff] [blame] | 114 | Contexts.back().IsExpression = true; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 115 | } else if (Line.InPPDirective && |
| 116 | (!Left->Previous || |
| 117 | (Left->Previous->isNot(tok::identifier) && |
| 118 | Left->Previous->Type != TT_OverloadedOperator))) { |
| 119 | Contexts.back().IsExpression = true; |
Daniel Jasper | 363193b | 2013-10-20 18:15:30 +0000 | [diff] [blame] | 120 | } else if (Left->Previous && Left->Previous->is(tok::r_square) && |
| 121 | Left->Previous->MatchingParen && |
| 122 | Left->Previous->MatchingParen->Type == TT_LambdaLSquare) { |
| 123 | // This is a parameter list of a lambda expression. |
| 124 | Contexts.back().IsExpression = false; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 125 | } else if (Contexts[Contexts.size() - 2].CaretFound) { |
| 126 | // This is the parameter list of an ObjC block. |
| 127 | Contexts.back().IsExpression = false; |
| 128 | } else if (Left->Previous && Left->Previous->is(tok::kw___attribute)) { |
| 129 | Left->Type = TT_AttributeParen; |
| 130 | } else if (Left->Previous && Left->Previous->IsForEachMacro) { |
| 131 | // The first argument to a foreach macro is a declaration. |
| 132 | Contexts.back().IsForEachMacro = true; |
| 133 | Contexts.back().IsExpression = false; |
Daniel Jasper | 363193b | 2013-10-20 18:15:30 +0000 | [diff] [blame] | 134 | } |
Daniel Jasper | b7000ca | 2013-08-01 17:58:23 +0000 | [diff] [blame] | 135 | |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 136 | if (StartsObjCMethodExpr) { |
| 137 | Contexts.back().ColonIsObjCMethodExpr = true; |
| 138 | Left->Type = TT_ObjCMethodExpr; |
| 139 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 140 | |
Daniel Jasper | 431f591 | 2013-05-28 08:33:00 +0000 | [diff] [blame] | 141 | bool MightBeFunctionType = CurrentToken->is(tok::star); |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 142 | bool HasMultipleLines = false; |
| 143 | bool HasMultipleParametersOnALine = false; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 144 | while (CurrentToken) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 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. |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 149 | if (LookForDecls && CurrentToken->Next) { |
Alexander Kornienko | 0bdc643 | 2013-07-04 14:47:51 +0000 | [diff] [blame] | 150 | FormatToken *Prev = CurrentToken->getPreviousNonComment(); |
Alexander Kornienko | 2785b9a | 2013-06-07 16:02:52 +0000 | [diff] [blame] | 151 | if (Prev) { |
Alexander Kornienko | 0bdc643 | 2013-07-04 14:47:51 +0000 | [diff] [blame] | 152 | FormatToken *PrevPrev = Prev->getPreviousNonComment(); |
Alexander Kornienko | 2785b9a | 2013-06-07 16:02:52 +0000 | [diff] [blame] | 153 | FormatToken *Next = CurrentToken->Next; |
| 154 | if (PrevPrev && PrevPrev->is(tok::identifier) && |
| 155 | Prev->isOneOf(tok::star, tok::amp, tok::ampamp) && |
| 156 | CurrentToken->is(tok::identifier) && Next->isNot(tok::equal)) { |
| 157 | Prev->Type = TT_BinaryOperator; |
| 158 | LookForDecls = false; |
| 159 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 160 | } |
| 161 | } |
| 162 | |
Daniel Jasper | 5335260 | 2013-08-12 12:16:34 +0000 | [diff] [blame] | 163 | if (CurrentToken->Previous->Type == TT_PointerOrReference && |
| 164 | CurrentToken->Previous->Previous->isOneOf(tok::l_paren, |
| 165 | tok::coloncolon)) |
| 166 | MightBeFunctionType = true; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 167 | if (CurrentToken->is(tok::r_paren)) { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 168 | if (MightBeFunctionType && CurrentToken->Next && |
Daniel Jasper | e7d3bff | 2013-07-16 11:37:21 +0000 | [diff] [blame] | 169 | (CurrentToken->Next->is(tok::l_paren) || |
| 170 | (CurrentToken->Next->is(tok::l_square) && |
| 171 | !Contexts.back().IsExpression))) |
Daniel Jasper | 431f591 | 2013-05-28 08:33:00 +0000 | [diff] [blame] | 172 | Left->Type = TT_FunctionTypeLParen; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 173 | Left->MatchingParen = CurrentToken; |
| 174 | CurrentToken->MatchingParen = Left; |
| 175 | |
Daniel Jasper | 63d7ced | 2013-02-05 10:07:47 +0000 | [diff] [blame] | 176 | if (StartsObjCMethodExpr) { |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 177 | CurrentToken->Type = TT_ObjCMethodExpr; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 178 | if (Contexts.back().FirstObjCSelectorName) { |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 179 | Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = |
| 180 | Contexts.back().LongestObjCSelectorName; |
Daniel Jasper | 63d7ced | 2013-02-05 10:07:47 +0000 | [diff] [blame] | 181 | } |
| 182 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 183 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 184 | if (Left->Type == TT_AttributeParen) |
| 185 | CurrentToken->Type = TT_AttributeParen; |
| 186 | |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 187 | if (!HasMultipleLines) |
| 188 | Left->PackingKind = PPK_Inconclusive; |
| 189 | else if (HasMultipleParametersOnALine) |
| 190 | Left->PackingKind = PPK_BinPacked; |
| 191 | else |
| 192 | Left->PackingKind = PPK_OnePerLine; |
| 193 | |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 194 | next(); |
| 195 | return true; |
| 196 | } |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 197 | if (CurrentToken->isOneOf(tok::r_square, tok::r_brace)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 198 | return false; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 199 | else if (CurrentToken->is(tok::l_brace)) |
| 200 | Left->Type = TT_Unknown; // Not TT_ObjCBlockLParen |
Daniel Jasper | 9fc56f2 | 2013-02-14 15:01:34 +0000 | [diff] [blame] | 201 | updateParameterCount(Left, CurrentToken); |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 202 | if (CurrentToken->is(tok::comma) && CurrentToken->Next && |
| 203 | !CurrentToken->Next->HasUnescapedNewline && |
| 204 | !CurrentToken->Next->isTrailingComment()) |
| 205 | HasMultipleParametersOnALine = true; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 206 | if (CurrentToken->isOneOf(tok::kw_const, tok::kw_auto) || |
| 207 | CurrentToken->isSimpleTypeSpecifier()) |
| 208 | Contexts.back().IsExpression = false; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 209 | if (!consumeToken()) |
| 210 | return false; |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 211 | if (CurrentToken && CurrentToken->HasUnescapedNewline) |
| 212 | HasMultipleLines = true; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 213 | } |
| 214 | return false; |
| 215 | } |
| 216 | |
| 217 | bool parseSquare() { |
| 218 | if (!CurrentToken) |
| 219 | return false; |
| 220 | |
Alexander Kornienko | d71b15b | 2013-06-17 13:19:53 +0000 | [diff] [blame] | 221 | // A '[' could be an index subscript (after an identifier or after |
Nico Weber | 051860e | 2013-02-10 02:08:05 +0000 | [diff] [blame] | 222 | // ')' or ']'), it could be the start of an Objective-C method |
| 223 | // expression, or it could the the start of an Objective-C array literal. |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 224 | FormatToken *Left = CurrentToken->Previous; |
Alexander Kornienko | 0bdc643 | 2013-07-04 14:47:51 +0000 | [diff] [blame] | 225 | FormatToken *Parent = Left->getPreviousNonComment(); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 226 | bool StartsObjCMethodExpr = |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 227 | Contexts.back().CanBeExpression && Left->Type != TT_LambdaLSquare && |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 228 | CurrentToken->isNot(tok::l_brace) && |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 229 | (!Parent || Parent->isOneOf(tok::colon, tok::l_square, tok::l_paren, |
| 230 | tok::kw_return, tok::kw_throw) || |
Daniel Jasper | ac3223e | 2013-04-10 09:49:49 +0000 | [diff] [blame] | 231 | Parent->isUnaryOperator() || Parent->Type == TT_ObjCForIn || |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 232 | Parent->Type == TT_CastRParen || |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 233 | getBinOpPrecedence(Parent->Tok.getKind(), true, true) > prec::Unknown); |
Daniel Jasper | 923ebef | 2013-03-14 13:45:21 +0000 | [diff] [blame] | 234 | ScopedContextCreator ContextCreator(*this, tok::l_square, 10); |
Daniel Jasper | 6f21a98 | 2013-03-13 07:49:51 +0000 | [diff] [blame] | 235 | Contexts.back().IsExpression = true; |
Daniel Jasper | 8f54d88 | 2013-10-26 17:00:22 +0000 | [diff] [blame] | 236 | bool ColonFound = false; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 237 | |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 238 | if (StartsObjCMethodExpr) { |
| 239 | Contexts.back().ColonIsObjCMethodExpr = true; |
| 240 | Left->Type = TT_ObjCMethodExpr; |
Daniel Jasper | a07aa66 | 2013-10-22 15:30:28 +0000 | [diff] [blame] | 241 | } else if (Parent && Parent->is(tok::at)) { |
| 242 | Left->Type = TT_ArrayInitializerLSquare; |
| 243 | } else if (Left->Type == TT_Unknown) { |
| 244 | Left->Type = TT_ArraySubscriptLSquare; |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 245 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 246 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 247 | while (CurrentToken) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 248 | if (CurrentToken->is(tok::r_square)) { |
Daniel Jasper | ac2c974 | 2013-09-05 10:04:31 +0000 | [diff] [blame] | 249 | if (CurrentToken->Next && CurrentToken->Next->is(tok::l_paren) && |
| 250 | Left->Type == TT_ObjCMethodExpr) { |
Nico Weber | e8a9798 | 2013-02-06 06:20:11 +0000 | [diff] [blame] | 251 | // An ObjC method call is rarely followed by an open parenthesis. |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 252 | // FIXME: Do we incorrectly label ":" with this? |
| 253 | StartsObjCMethodExpr = false; |
| 254 | Left->Type = TT_Unknown; |
| 255 | } |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 256 | if (StartsObjCMethodExpr && CurrentToken->Previous != Left) { |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 257 | CurrentToken->Type = TT_ObjCMethodExpr; |
Nico Weber | e8a9798 | 2013-02-06 06:20:11 +0000 | [diff] [blame] | 258 | // determineStarAmpUsage() thinks that '*' '[' is allocating an |
| 259 | // array of pointers, but if '[' starts a selector then '*' is a |
| 260 | // binary operator. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 261 | if (Parent && Parent->Type == TT_PointerOrReference) |
Nico Weber | 4ed7f3e | 2013-02-06 16:54:35 +0000 | [diff] [blame] | 262 | Parent->Type = TT_BinaryOperator; |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 263 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 264 | Left->MatchingParen = CurrentToken; |
| 265 | CurrentToken->MatchingParen = Left; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 266 | if (Contexts.back().FirstObjCSelectorName) { |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 267 | Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = |
| 268 | Contexts.back().LongestObjCSelectorName; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 269 | if (Contexts.back().NumBlockParameters > 1) |
| 270 | Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = 0; |
| 271 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 272 | next(); |
| 273 | return true; |
| 274 | } |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 275 | if (CurrentToken->isOneOf(tok::r_paren, tok::r_brace)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 276 | return false; |
Daniel Jasper | 8f54d88 | 2013-10-26 17:00:22 +0000 | [diff] [blame] | 277 | if (CurrentToken->is(tok::colon)) |
| 278 | ColonFound = true; |
Daniel Jasper | a07aa66 | 2013-10-22 15:30:28 +0000 | [diff] [blame] | 279 | if (CurrentToken->is(tok::comma) && |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 280 | Style.Language != FormatStyle::LK_Proto && |
Daniel Jasper | 3c6aea7 | 2013-10-24 10:31:50 +0000 | [diff] [blame] | 281 | (Left->Type == TT_ArraySubscriptLSquare || |
Daniel Jasper | 8f54d88 | 2013-10-26 17:00:22 +0000 | [diff] [blame] | 282 | (Left->Type == TT_ObjCMethodExpr && !ColonFound))) |
Daniel Jasper | a07aa66 | 2013-10-22 15:30:28 +0000 | [diff] [blame] | 283 | Left->Type = TT_ArrayInitializerLSquare; |
Daniel Jasper | 9fc56f2 | 2013-02-14 15:01:34 +0000 | [diff] [blame] | 284 | updateParameterCount(Left, CurrentToken); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 285 | if (!consumeToken()) |
| 286 | return false; |
| 287 | } |
| 288 | return false; |
| 289 | } |
| 290 | |
| 291 | bool parseBrace() { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 292 | if (CurrentToken) { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 293 | FormatToken *Left = CurrentToken->Previous; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 294 | |
| 295 | if (Contexts.back().CaretFound) |
| 296 | Left->Type = TT_ObjCBlockLBrace; |
| 297 | Contexts.back().CaretFound = false; |
| 298 | |
Daniel Jasper | 3c6aea7 | 2013-10-24 10:31:50 +0000 | [diff] [blame] | 299 | ScopedContextCreator ContextCreator(*this, tok::l_brace, 1); |
| 300 | Contexts.back().ColonIsDictLiteral = true; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 301 | if (Left->BlockKind == BK_BracedInit) |
| 302 | Contexts.back().IsExpression = true; |
Nico Weber | f2ff812 | 2013-05-26 05:39:26 +0000 | [diff] [blame] | 303 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 304 | while (CurrentToken) { |
Daniel Jasper | 53e72cd | 2013-05-06 08:27:33 +0000 | [diff] [blame] | 305 | if (CurrentToken->is(tok::r_brace)) { |
| 306 | Left->MatchingParen = CurrentToken; |
| 307 | CurrentToken->MatchingParen = Left; |
| 308 | next(); |
| 309 | return true; |
| 310 | } |
| 311 | if (CurrentToken->isOneOf(tok::r_paren, tok::r_square)) |
| 312 | return false; |
| 313 | updateParameterCount(Left, CurrentToken); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 314 | if (CurrentToken->is(tok::colon) && |
| 315 | Style.Language != FormatStyle::LK_Proto) |
Daniel Jasper | 3c6aea7 | 2013-10-24 10:31:50 +0000 | [diff] [blame] | 316 | Left->Type = TT_DictLiteral; |
Daniel Jasper | 53e72cd | 2013-05-06 08:27:33 +0000 | [diff] [blame] | 317 | if (!consumeToken()) |
| 318 | return false; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 319 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 320 | } |
Daniel Jasper | 53e72cd | 2013-05-06 08:27:33 +0000 | [diff] [blame] | 321 | // No closing "}" found, this probably starts a definition. |
| 322 | Line.StartsDefinition = true; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 323 | return true; |
| 324 | } |
Daniel Jasper | c4615b7 | 2013-02-20 12:56:39 +0000 | [diff] [blame] | 325 | |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 326 | void updateParameterCount(FormatToken *Left, FormatToken *Current) { |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 327 | if (Current->is(tok::comma)) { |
Daniel Jasper | 9fc56f2 | 2013-02-14 15:01:34 +0000 | [diff] [blame] | 328 | ++Left->ParameterCount; |
Daniel Jasper | d4a03db | 2013-08-22 15:00:41 +0000 | [diff] [blame] | 329 | if (!Left->Role) |
| 330 | Left->Role.reset(new CommaSeparatedList(Style)); |
| 331 | Left->Role->CommaFound(Current); |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 332 | } else if (Left->ParameterCount == 0 && Current->isNot(tok::comment)) { |
Daniel Jasper | 9fc56f2 | 2013-02-14 15:01:34 +0000 | [diff] [blame] | 333 | Left->ParameterCount = 1; |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 334 | } |
Daniel Jasper | 9fc56f2 | 2013-02-14 15:01:34 +0000 | [diff] [blame] | 335 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 336 | |
| 337 | bool parseConditional() { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 338 | while (CurrentToken) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 339 | if (CurrentToken->is(tok::colon)) { |
| 340 | CurrentToken->Type = TT_ConditionalExpr; |
| 341 | next(); |
| 342 | return true; |
| 343 | } |
| 344 | if (!consumeToken()) |
| 345 | return false; |
| 346 | } |
| 347 | return false; |
| 348 | } |
| 349 | |
| 350 | bool parseTemplateDeclaration() { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 351 | if (CurrentToken && CurrentToken->is(tok::less)) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 352 | CurrentToken->Type = TT_TemplateOpener; |
| 353 | next(); |
| 354 | if (!parseAngle()) |
| 355 | return false; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 356 | if (CurrentToken) |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 357 | CurrentToken->Previous->ClosesTemplateDeclaration = true; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 358 | return true; |
| 359 | } |
| 360 | return false; |
| 361 | } |
| 362 | |
| 363 | bool consumeToken() { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 364 | FormatToken *Tok = CurrentToken; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 365 | next(); |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 366 | switch (Tok->Tok.getKind()) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 367 | case tok::plus: |
| 368 | case tok::minus: |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 369 | if (!Tok->Previous && Line.MustBeDeclaration) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 370 | Tok->Type = TT_ObjCMethodSpecifier; |
| 371 | break; |
| 372 | case tok::colon: |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 373 | if (!Tok->Previous) |
Daniel Jasper | cf6d76a | 2013-03-18 12:50:26 +0000 | [diff] [blame] | 374 | return false; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 375 | // Colons from ?: are handled in parseConditional(). |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 376 | if (Tok->Previous->is(tok::r_paren) && Contexts.size() == 1 && |
| 377 | Line.First->isNot(tok::kw_case)) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 378 | Tok->Type = TT_CtorInitializerColon; |
Daniel Jasper | 3c6aea7 | 2013-10-24 10:31:50 +0000 | [diff] [blame] | 379 | } else if (Contexts.back().ColonIsDictLiteral) { |
| 380 | Tok->Type = TT_DictLiteral; |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 381 | } else if (Contexts.back().ColonIsObjCMethodExpr || |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 382 | Line.First->Type == TT_ObjCMethodSpecifier) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 383 | Tok->Type = TT_ObjCMethodExpr; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 384 | Tok->Previous->Type = TT_ObjCSelectorName; |
Alexander Kornienko | 83a7dcd | 2013-09-10 09:38:25 +0000 | [diff] [blame] | 385 | if (Tok->Previous->ColumnWidth > |
Alexander Kornienko | 0089510 | 2013-06-05 14:09:10 +0000 | [diff] [blame] | 386 | Contexts.back().LongestObjCSelectorName) { |
Alexander Kornienko | 01fe9f9 | 2013-10-10 13:36:20 +0000 | [diff] [blame] | 387 | Contexts.back().LongestObjCSelectorName = Tok->Previous->ColumnWidth; |
Alexander Kornienko | 0089510 | 2013-06-05 14:09:10 +0000 | [diff] [blame] | 388 | } |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 389 | if (!Contexts.back().FirstObjCSelectorName) |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 390 | Contexts.back().FirstObjCSelectorName = Tok->Previous; |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 391 | } else if (Contexts.back().ColonIsForRangeExpr) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 392 | Tok->Type = TT_RangeBasedForLoopColon; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 393 | } else if (CurrentToken && CurrentToken->is(tok::numeric_constant)) { |
Alexander Kornienko | 01fe9f9 | 2013-10-10 13:36:20 +0000 | [diff] [blame] | 394 | Tok->Type = TT_BitFieldColon; |
Daniel Jasper | cea014b | 2013-10-08 16:24:07 +0000 | [diff] [blame] | 395 | } else if (Contexts.size() == 1 && Line.First->isNot(tok::kw_enum)) { |
Daniel Jasper | 6cabab4 | 2013-02-14 08:42:54 +0000 | [diff] [blame] | 396 | Tok->Type = TT_InheritanceColon; |
Daniel Jasper | 923ebef | 2013-03-14 13:45:21 +0000 | [diff] [blame] | 397 | } else if (Contexts.back().ContextKind == tok::l_paren) { |
| 398 | Tok->Type = TT_InlineASMColon; |
Daniel Jasper | 63d7ced | 2013-02-05 10:07:47 +0000 | [diff] [blame] | 399 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 400 | break; |
| 401 | case tok::kw_if: |
| 402 | case tok::kw_while: |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 403 | if (CurrentToken && CurrentToken->is(tok::l_paren)) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 404 | next(); |
Nico Weber | 2726877 | 2013-06-26 00:30:14 +0000 | [diff] [blame] | 405 | if (!parseParens(/*LookForDecls=*/true)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 406 | return false; |
| 407 | } |
| 408 | break; |
| 409 | case tok::kw_for: |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 410 | Contexts.back().ColonIsForRangeExpr = true; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 411 | next(); |
| 412 | if (!parseParens()) |
| 413 | return false; |
| 414 | break; |
| 415 | case tok::l_paren: |
| 416 | if (!parseParens()) |
| 417 | return false; |
Daniel Jasper | 59875ac | 2013-11-07 17:43:07 +0000 | [diff] [blame] | 418 | if (Line.MustBeDeclaration && Contexts.size() == 1 && |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 419 | !Contexts.back().IsExpression && |
| 420 | Line.First->Type != TT_ObjCProperty && |
| 421 | (!Tok->Previous || Tok->Previous->isNot(tok::kw_decltype))) |
Daniel Jasper | 3c08a81 | 2013-02-24 18:54:32 +0000 | [diff] [blame] | 422 | Line.MightBeFunctionDecl = true; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 423 | break; |
| 424 | case tok::l_square: |
| 425 | if (!parseSquare()) |
| 426 | return false; |
| 427 | break; |
| 428 | case tok::l_brace: |
| 429 | if (!parseBrace()) |
| 430 | return false; |
| 431 | break; |
| 432 | case tok::less: |
Daniel Jasper | 0236dd0 | 2013-07-30 22:37:19 +0000 | [diff] [blame] | 433 | if (Tok->Previous && !Tok->Previous->Tok.isLiteral() && parseAngle()) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 434 | Tok->Type = TT_TemplateOpener; |
| 435 | else { |
| 436 | Tok->Type = TT_BinaryOperator; |
| 437 | CurrentToken = Tok; |
| 438 | next(); |
| 439 | } |
| 440 | break; |
| 441 | case tok::r_paren: |
| 442 | case tok::r_square: |
| 443 | return false; |
| 444 | case tok::r_brace: |
| 445 | // Lines can start with '}'. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 446 | if (Tok->Previous) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 447 | return false; |
| 448 | break; |
| 449 | case tok::greater: |
| 450 | Tok->Type = TT_BinaryOperator; |
| 451 | break; |
| 452 | case tok::kw_operator: |
Daniel Jasper | 174f60f | 2013-09-02 09:20:39 +0000 | [diff] [blame] | 453 | while (CurrentToken && |
| 454 | !CurrentToken->isOneOf(tok::l_paren, tok::semi, tok::r_paren)) { |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 455 | if (CurrentToken->isOneOf(tok::star, tok::amp)) |
Daniel Jasper | 2b4c924 | 2013-02-11 08:01:18 +0000 | [diff] [blame] | 456 | CurrentToken->Type = TT_PointerOrReference; |
| 457 | consumeToken(); |
Daniel Jasper | 174f60f | 2013-09-02 09:20:39 +0000 | [diff] [blame] | 458 | if (CurrentToken && CurrentToken->Previous->Type == TT_BinaryOperator) |
Daniel Jasper | c476ea9 | 2013-08-28 07:27:35 +0000 | [diff] [blame] | 459 | CurrentToken->Previous->Type = TT_OverloadedOperator; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 460 | } |
Daniel Jasper | 6ea933c | 2013-05-10 07:59:58 +0000 | [diff] [blame] | 461 | if (CurrentToken) { |
Daniel Jasper | 2b4c924 | 2013-02-11 08:01:18 +0000 | [diff] [blame] | 462 | CurrentToken->Type = TT_OverloadedOperatorLParen; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 463 | if (CurrentToken->Previous->Type == TT_BinaryOperator) |
| 464 | CurrentToken->Previous->Type = TT_OverloadedOperator; |
Daniel Jasper | 6ea933c | 2013-05-10 07:59:58 +0000 | [diff] [blame] | 465 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 466 | break; |
| 467 | case tok::question: |
| 468 | parseConditional(); |
| 469 | break; |
| 470 | case tok::kw_template: |
| 471 | parseTemplateDeclaration(); |
| 472 | break; |
Nico Weber | c2e6d2a | 2013-02-11 15:32:15 +0000 | [diff] [blame] | 473 | case tok::identifier: |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 474 | if (Line.First->is(tok::kw_for) && |
| 475 | Tok->Tok.getIdentifierInfo() == &Ident_in) |
Nico Weber | c2e6d2a | 2013-02-11 15:32:15 +0000 | [diff] [blame] | 476 | Tok->Type = TT_ObjCForIn; |
| 477 | break; |
Daniel Jasper | 8ed9f2b | 2013-04-03 13:36:17 +0000 | [diff] [blame] | 478 | case tok::comma: |
| 479 | if (Contexts.back().FirstStartOfName) |
| 480 | Contexts.back().FirstStartOfName->PartOfMultiVariableDeclStmt = true; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 481 | if (Contexts.back().InCtorInitializer) |
| 482 | Tok->Type = TT_CtorInitializerComma; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 483 | if (Contexts.back().IsForEachMacro) |
| 484 | Contexts.back().IsExpression = true; |
Daniel Jasper | 8ed9f2b | 2013-04-03 13:36:17 +0000 | [diff] [blame] | 485 | break; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 486 | default: |
| 487 | break; |
| 488 | } |
| 489 | return true; |
| 490 | } |
| 491 | |
| 492 | void parseIncludeDirective() { |
| 493 | next(); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 494 | if (CurrentToken && CurrentToken->is(tok::less)) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 495 | next(); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 496 | while (CurrentToken) { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 497 | if (CurrentToken->isNot(tok::comment) || CurrentToken->Next) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 498 | CurrentToken->Type = TT_ImplicitStringLiteral; |
| 499 | next(); |
| 500 | } |
| 501 | } else { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 502 | while (CurrentToken) { |
Daniel Jasper | 3a20441 | 2013-02-23 07:46:38 +0000 | [diff] [blame] | 503 | if (CurrentToken->is(tok::string_literal)) |
| 504 | // Mark these string literals as "implicit" literals, too, so that |
| 505 | // they are not split or line-wrapped. |
| 506 | CurrentToken->Type = TT_ImplicitStringLiteral; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 507 | next(); |
| 508 | } |
| 509 | } |
| 510 | } |
| 511 | |
| 512 | void parseWarningOrError() { |
| 513 | next(); |
| 514 | // We still want to format the whitespace left of the first token of the |
| 515 | // warning or error. |
| 516 | next(); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 517 | while (CurrentToken) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 518 | CurrentToken->Type = TT_ImplicitStringLiteral; |
| 519 | next(); |
| 520 | } |
| 521 | } |
| 522 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 523 | void parsePragma() { |
| 524 | next(); // Consume "pragma". |
| 525 | if (CurrentToken && CurrentToken->TokenText == "mark") { |
| 526 | next(); // Consume "mark". |
| 527 | next(); // Consume first token (so we fix leading whitespace). |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 528 | while (CurrentToken) { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 529 | CurrentToken->Type = TT_ImplicitStringLiteral; |
| 530 | next(); |
| 531 | } |
| 532 | } |
| 533 | } |
| 534 | |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 535 | void parsePreprocessorDirective() { |
| 536 | next(); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 537 | if (!CurrentToken) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 538 | return; |
Alexander Kornienko | b18c258 | 2013-10-11 21:43:05 +0000 | [diff] [blame] | 539 | if (CurrentToken->Tok.is(tok::numeric_constant)) { |
| 540 | CurrentToken->SpacesRequiredBefore = 1; |
| 541 | return; |
| 542 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 543 | // Hashes in the middle of a line can lead to any strange token |
| 544 | // sequence. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 545 | if (!CurrentToken->Tok.getIdentifierInfo()) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 546 | return; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 547 | switch (CurrentToken->Tok.getIdentifierInfo()->getPPKeywordID()) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 548 | case tok::pp_include: |
| 549 | case tok::pp_import: |
| 550 | parseIncludeDirective(); |
| 551 | break; |
| 552 | case tok::pp_error: |
| 553 | case tok::pp_warning: |
| 554 | parseWarningOrError(); |
| 555 | break; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 556 | case tok::pp_pragma: |
| 557 | parsePragma(); |
| 558 | break; |
Daniel Jasper | aae7bad | 2013-04-23 13:54:04 +0000 | [diff] [blame] | 559 | case tok::pp_if: |
| 560 | case tok::pp_elif: |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 561 | Contexts.back().IsExpression = true; |
Daniel Jasper | aae7bad | 2013-04-23 13:54:04 +0000 | [diff] [blame] | 562 | parseLine(); |
| 563 | break; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 564 | default: |
| 565 | break; |
| 566 | } |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 567 | while (CurrentToken) |
Daniel Jasper | 5b7e7b0 | 2013-02-05 09:34:14 +0000 | [diff] [blame] | 568 | next(); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 569 | } |
| 570 | |
Nico Weber | 95e8e46 | 2013-02-12 16:17:07 +0000 | [diff] [blame] | 571 | public: |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 572 | LineType parseLine() { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 573 | if (CurrentToken->is(tok::hash)) { |
| 574 | parsePreprocessorDirective(); |
| 575 | return LT_PreprocessorDirective; |
| 576 | } |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 577 | |
| 578 | // Directly allow to 'import <string-literal>' to support protocol buffer |
| 579 | // definitions (code.google.com/p/protobuf) or missing "#" (either way we |
| 580 | // should not break the line). |
| 581 | IdentifierInfo *Info = CurrentToken->Tok.getIdentifierInfo(); |
| 582 | if (Info && Info->getPPKeywordID() == tok::pp_import && |
| 583 | CurrentToken->Next && CurrentToken->Next->is(tok::string_literal)) |
| 584 | parseIncludeDirective(); |
| 585 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 586 | while (CurrentToken) { |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 587 | if (CurrentToken->is(tok::kw_virtual)) |
| 588 | KeywordVirtualFound = true; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 589 | if (!consumeToken()) |
| 590 | return LT_Invalid; |
| 591 | } |
| 592 | if (KeywordVirtualFound) |
| 593 | return LT_VirtualFunctionDecl; |
| 594 | |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 595 | if (Line.First->Type == TT_ObjCMethodSpecifier) { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 596 | if (Contexts.back().FirstObjCSelectorName) |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 597 | Contexts.back().FirstObjCSelectorName->LongestObjCSelectorName = |
| 598 | Contexts.back().LongestObjCSelectorName; |
Daniel Jasper | 63d7ced | 2013-02-05 10:07:47 +0000 | [diff] [blame] | 599 | return LT_ObjCMethodDecl; |
| 600 | } |
| 601 | |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 602 | return LT_Other; |
| 603 | } |
| 604 | |
Nico Weber | 95e8e46 | 2013-02-12 16:17:07 +0000 | [diff] [blame] | 605 | private: |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 606 | void resetTokenMetadata(FormatToken *Token) { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 607 | if (!Token) |
| 608 | return; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 609 | |
| 610 | // Reset token type in case we have already looked at it and then |
| 611 | // recovered from an error (e.g. failure to find the matching >). |
| 612 | if (CurrentToken->Type != TT_LambdaLSquare && |
| 613 | CurrentToken->Type != TT_FunctionLBrace && |
| 614 | CurrentToken->Type != TT_ImplicitStringLiteral && |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 615 | CurrentToken->Type != TT_RegexLiteral && |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 616 | CurrentToken->Type != TT_TrailingReturnArrow) |
| 617 | CurrentToken->Type = TT_Unknown; |
| 618 | if (CurrentToken->Role) |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 619 | CurrentToken->Role.reset(nullptr); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 620 | CurrentToken->FakeLParens.clear(); |
| 621 | CurrentToken->FakeRParens = 0; |
| 622 | } |
| 623 | |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 624 | void next() { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 625 | if (CurrentToken) { |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 626 | determineTokenType(*CurrentToken); |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 627 | CurrentToken->BindingStrength = Contexts.back().BindingStrength; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 628 | CurrentToken->NestingLevel = Contexts.size() - 1; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 629 | CurrentToken = CurrentToken->Next; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 630 | } |
Daniel Jasper | d0f349b | 2013-02-18 12:44:35 +0000 | [diff] [blame] | 631 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 632 | resetTokenMetadata(CurrentToken); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 633 | } |
| 634 | |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 635 | /// \brief A struct to hold information valid in a specific context, e.g. |
| 636 | /// a pair of parenthesis. |
| 637 | struct Context { |
Daniel Jasper | 923ebef | 2013-03-14 13:45:21 +0000 | [diff] [blame] | 638 | Context(tok::TokenKind ContextKind, unsigned BindingStrength, |
| 639 | bool IsExpression) |
| 640 | : ContextKind(ContextKind), BindingStrength(BindingStrength), |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 641 | LongestObjCSelectorName(0), NumBlockParameters(0), |
| 642 | ColonIsForRangeExpr(false), ColonIsDictLiteral(false), |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 643 | ColonIsObjCMethodExpr(false), FirstObjCSelectorName(nullptr), |
| 644 | FirstStartOfName(nullptr), IsExpression(IsExpression), |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 645 | CanBeExpression(true), InTemplateArgument(false), |
| 646 | InCtorInitializer(false), CaretFound(false), IsForEachMacro(false) {} |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 647 | |
Daniel Jasper | 923ebef | 2013-03-14 13:45:21 +0000 | [diff] [blame] | 648 | tok::TokenKind ContextKind; |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 649 | unsigned BindingStrength; |
| 650 | unsigned LongestObjCSelectorName; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 651 | unsigned NumBlockParameters; |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 652 | bool ColonIsForRangeExpr; |
Daniel Jasper | 3c6aea7 | 2013-10-24 10:31:50 +0000 | [diff] [blame] | 653 | bool ColonIsDictLiteral; |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 654 | bool ColonIsObjCMethodExpr; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 655 | FormatToken *FirstObjCSelectorName; |
| 656 | FormatToken *FirstStartOfName; |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 657 | bool IsExpression; |
Daniel Jasper | 6f21a98 | 2013-03-13 07:49:51 +0000 | [diff] [blame] | 658 | bool CanBeExpression; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 659 | bool InTemplateArgument; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 660 | bool InCtorInitializer; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 661 | bool CaretFound; |
| 662 | bool IsForEachMacro; |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 663 | }; |
| 664 | |
| 665 | /// \brief Puts a new \c Context onto the stack \c Contexts for the lifetime |
| 666 | /// of each instance. |
| 667 | struct ScopedContextCreator { |
| 668 | AnnotatingParser &P; |
| 669 | |
Daniel Jasper | 923ebef | 2013-03-14 13:45:21 +0000 | [diff] [blame] | 670 | ScopedContextCreator(AnnotatingParser &P, tok::TokenKind ContextKind, |
| 671 | unsigned Increase) |
| 672 | : P(P) { |
Daniel Jasper | 2a409b6 | 2013-07-08 14:34:09 +0000 | [diff] [blame] | 673 | P.Contexts.push_back(Context(ContextKind, |
| 674 | P.Contexts.back().BindingStrength + Increase, |
| 675 | P.Contexts.back().IsExpression)); |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 676 | } |
| 677 | |
| 678 | ~ScopedContextCreator() { P.Contexts.pop_back(); } |
| 679 | }; |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 680 | |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 681 | void determineTokenType(FormatToken &Current) { |
| 682 | if (Current.getPrecedence() == prec::Assignment && |
Daniel Jasper | 5335260 | 2013-08-12 12:16:34 +0000 | [diff] [blame] | 683 | !Line.First->isOneOf(tok::kw_template, tok::kw_using) && |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 684 | (!Current.Previous || Current.Previous->isNot(tok::kw_operator))) { |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 685 | Contexts.back().IsExpression = true; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 686 | for (FormatToken *Previous = Current.Previous; |
Daniel Jasper | 7e27400 | 2013-09-11 20:37:10 +0000 | [diff] [blame] | 687 | Previous && !Previous->isOneOf(tok::comma, tok::semi); |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 688 | Previous = Previous->Previous) { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 689 | if (Previous->isOneOf(tok::r_square, tok::r_paren)) |
Daniel Jasper | 9c65b06 | 2013-02-27 11:43:50 +0000 | [diff] [blame] | 690 | Previous = Previous->MatchingParen; |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 691 | if (Previous->Type == TT_BinaryOperator && |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 692 | Previous->isOneOf(tok::star, tok::amp)) { |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 693 | Previous->Type = TT_PointerOrReference; |
| 694 | } |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 695 | } |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 696 | } else if (Current.isOneOf(tok::kw_return, tok::kw_throw)) { |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 697 | Contexts.back().IsExpression = true; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 698 | } else if (Current.is(tok::l_paren) && !Line.MustBeDeclaration && |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 699 | !Line.InPPDirective && |
| 700 | (!Current.Previous || |
| 701 | Current.Previous->isNot(tok::kw_decltype))) { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 702 | bool ParametersOfFunctionType = |
| 703 | Current.Previous && Current.Previous->is(tok::r_paren) && |
| 704 | Current.Previous->MatchingParen && |
| 705 | Current.Previous->MatchingParen->Type == TT_FunctionTypeLParen; |
| 706 | bool IsForOrCatch = Current.Previous && |
| 707 | Current.Previous->isOneOf(tok::kw_for, tok::kw_catch); |
| 708 | Contexts.back().IsExpression = !ParametersOfFunctionType && !IsForOrCatch; |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 709 | } else if (Current.isOneOf(tok::r_paren, tok::greater, tok::comma)) { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 710 | for (FormatToken *Previous = Current.Previous; |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 711 | Previous && Previous->isOneOf(tok::star, tok::amp); |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 712 | Previous = Previous->Previous) |
Nico Weber | 95e8e46 | 2013-02-12 16:17:07 +0000 | [diff] [blame] | 713 | Previous->Type = TT_PointerOrReference; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 714 | } else if (Current.Previous && |
| 715 | Current.Previous->Type == TT_CtorInitializerColon) { |
Daniel Jasper | d0f349b | 2013-02-18 12:44:35 +0000 | [diff] [blame] | 716 | Contexts.back().IsExpression = true; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 717 | Contexts.back().InCtorInitializer = true; |
Daniel Jasper | 6f21a98 | 2013-03-13 07:49:51 +0000 | [diff] [blame] | 718 | } else if (Current.is(tok::kw_new)) { |
| 719 | Contexts.back().CanBeExpression = false; |
Daniel Jasper | f9504aa | 2013-11-07 19:56:07 +0000 | [diff] [blame] | 720 | } else if (Current.is(tok::semi) || Current.is(tok::exclaim)) { |
Daniel Jasper | 16a69ef | 2013-05-03 14:41:24 +0000 | [diff] [blame] | 721 | // This should be the condition or increment in a for-loop. |
| 722 | Contexts.back().IsExpression = true; |
Nico Weber | 95e8e46 | 2013-02-12 16:17:07 +0000 | [diff] [blame] | 723 | } |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 724 | |
| 725 | if (Current.Type == TT_Unknown) { |
Daniel Jasper | 6b3ff8c | 2013-09-27 08:29:16 +0000 | [diff] [blame] | 726 | // Line.MightBeFunctionDecl can only be true after the parentheses of a |
| 727 | // function declaration have been found. In this case, 'Current' is a |
| 728 | // trailing token of this declaration and thus cannot be a name. |
| 729 | if (isStartOfName(Current) && !Line.MightBeFunctionDecl) { |
Daniel Jasper | 8ed9f2b | 2013-04-03 13:36:17 +0000 | [diff] [blame] | 730 | Contexts.back().FirstStartOfName = &Current; |
Daniel Jasper | 3c08a81 | 2013-02-24 18:54:32 +0000 | [diff] [blame] | 731 | Current.Type = TT_StartOfName; |
Daniel Jasper | 2ca3741 | 2013-07-09 14:36:48 +0000 | [diff] [blame] | 732 | } else if (Current.is(tok::kw_auto)) { |
| 733 | AutoFound = true; |
Daniel Jasper | 3262f4c | 2013-07-11 14:33:06 +0000 | [diff] [blame] | 734 | } else if (Current.is(tok::arrow) && AutoFound && |
| 735 | Line.MustBeDeclaration) { |
Daniel Jasper | 2ca3741 | 2013-07-09 14:36:48 +0000 | [diff] [blame] | 736 | Current.Type = TT_TrailingReturnArrow; |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 737 | } else if (Current.isOneOf(tok::star, tok::amp, tok::ampamp)) { |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 738 | Current.Type = |
Daniel Jasper | d6104f6 | 2013-07-05 13:30:40 +0000 | [diff] [blame] | 739 | determineStarAmpUsage(Current, Contexts.back().CanBeExpression && |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 740 | Contexts.back().IsExpression, |
| 741 | Contexts.back().InTemplateArgument); |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 742 | } else if (Current.isOneOf(tok::minus, tok::plus, tok::caret)) { |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 743 | Current.Type = determinePlusMinusCaretUsage(Current); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 744 | if (Current.Type == TT_UnaryOperator && Current.is(tok::caret)) { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 745 | ++Contexts.back().NumBlockParameters; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 746 | Contexts.back().CaretFound = true; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 747 | } |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 748 | } else if (Current.isOneOf(tok::minusminus, tok::plusplus)) { |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 749 | Current.Type = determineIncrementUsage(Current); |
| 750 | } else if (Current.is(tok::exclaim)) { |
| 751 | Current.Type = TT_UnaryOperator; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 752 | } else if (Current.is(tok::question)) { |
| 753 | Current.Type = TT_ConditionalExpr; |
Manuel Klimek | 31e44f7 | 2013-09-04 08:20:47 +0000 | [diff] [blame] | 754 | } else if (Current.isBinaryOperator() && |
| 755 | (!Current.Previous || |
| 756 | Current.Previous->isNot(tok::l_square))) { |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 757 | Current.Type = TT_BinaryOperator; |
| 758 | } else if (Current.is(tok::comment)) { |
Alexander Kornienko | 0089510 | 2013-06-05 14:09:10 +0000 | [diff] [blame] | 759 | if (Current.TokenText.startswith("//")) |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 760 | Current.Type = TT_LineComment; |
| 761 | else |
| 762 | Current.Type = TT_BlockComment; |
Nico Weber | 37d6931 | 2013-02-13 04:13:13 +0000 | [diff] [blame] | 763 | } else if (Current.is(tok::r_paren)) { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 764 | if (rParenEndsCast(Current)) |
Nico Weber | 37d6931 | 2013-02-13 04:13:13 +0000 | [diff] [blame] | 765 | Current.Type = TT_CastRParen; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 766 | } else if (Current.is(tok::at) && Current.Next) { |
| 767 | switch (Current.Next->Tok.getObjCKeywordID()) { |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 768 | case tok::objc_interface: |
| 769 | case tok::objc_implementation: |
| 770 | case tok::objc_protocol: |
| 771 | Current.Type = TT_ObjCDecl; |
| 772 | break; |
| 773 | case tok::objc_property: |
| 774 | Current.Type = TT_ObjCProperty; |
| 775 | break; |
| 776 | default: |
| 777 | break; |
| 778 | } |
Daniel Jasper | 5ad390d | 2013-05-28 11:30:49 +0000 | [diff] [blame] | 779 | } else if (Current.is(tok::period)) { |
Alexander Kornienko | 0bdc643 | 2013-07-04 14:47:51 +0000 | [diff] [blame] | 780 | FormatToken *PreviousNoComment = Current.getPreviousNonComment(); |
Daniel Jasper | 5ad390d | 2013-05-28 11:30:49 +0000 | [diff] [blame] | 781 | if (PreviousNoComment && |
| 782 | PreviousNoComment->isOneOf(tok::comma, tok::l_brace)) |
| 783 | Current.Type = TT_DesignatedInitializerPeriod; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 784 | } else if (Current.isOneOf(tok::identifier, tok::kw_const) && |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 785 | Current.Previous && Current.Previous->isNot(tok::equal) && |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 786 | Line.MightBeFunctionDecl && Contexts.size() == 1) { |
| 787 | // Line.MightBeFunctionDecl can only be true after the parentheses of a |
| 788 | // function declaration have been found. |
| 789 | Current.Type = TT_TrailingAnnotation; |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 790 | } |
| 791 | } |
| 792 | } |
| 793 | |
Daniel Jasper | 6ac431c | 2013-07-02 09:47:29 +0000 | [diff] [blame] | 794 | /// \brief Take a guess at whether \p Tok starts a name of a function or |
| 795 | /// variable declaration. |
| 796 | /// |
| 797 | /// This is a heuristic based on whether \p Tok is an identifier following |
| 798 | /// something that is likely a type. |
| 799 | bool isStartOfName(const FormatToken &Tok) { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 800 | if (Tok.isNot(tok::identifier) || !Tok.Previous) |
Daniel Jasper | 6ac431c | 2013-07-02 09:47:29 +0000 | [diff] [blame] | 801 | return false; |
| 802 | |
| 803 | // Skip "const" as it does not have an influence on whether this is a name. |
| 804 | FormatToken *PreviousNotConst = Tok.Previous; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 805 | while (PreviousNotConst && PreviousNotConst->is(tok::kw_const)) |
Daniel Jasper | 6ac431c | 2013-07-02 09:47:29 +0000 | [diff] [blame] | 806 | PreviousNotConst = PreviousNotConst->Previous; |
| 807 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 808 | if (!PreviousNotConst) |
Daniel Jasper | 6ac431c | 2013-07-02 09:47:29 +0000 | [diff] [blame] | 809 | return false; |
| 810 | |
Daniel Jasper | 2a409b6 | 2013-07-08 14:34:09 +0000 | [diff] [blame] | 811 | bool IsPPKeyword = PreviousNotConst->is(tok::identifier) && |
| 812 | PreviousNotConst->Previous && |
| 813 | PreviousNotConst->Previous->is(tok::hash); |
Daniel Jasper | 6ac431c | 2013-07-02 09:47:29 +0000 | [diff] [blame] | 814 | |
Daniel Jasper | 92495a8 | 2013-08-19 10:16:18 +0000 | [diff] [blame] | 815 | if (PreviousNotConst->Type == TT_TemplateCloser) |
| 816 | return PreviousNotConst && PreviousNotConst->MatchingParen && |
| 817 | PreviousNotConst->MatchingParen->Previous && |
| 818 | PreviousNotConst->MatchingParen->Previous->isNot(tok::kw_template); |
| 819 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 820 | if (PreviousNotConst->is(tok::r_paren) && PreviousNotConst->MatchingParen && |
| 821 | PreviousNotConst->MatchingParen->Previous && |
| 822 | PreviousNotConst->MatchingParen->Previous->is(tok::kw_decltype)) |
| 823 | return true; |
| 824 | |
Daniel Jasper | 6ac431c | 2013-07-02 09:47:29 +0000 | [diff] [blame] | 825 | return (!IsPPKeyword && PreviousNotConst->is(tok::identifier)) || |
| 826 | PreviousNotConst->Type == TT_PointerOrReference || |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 827 | PreviousNotConst->isSimpleTypeSpecifier(); |
Daniel Jasper | 6ac431c | 2013-07-02 09:47:29 +0000 | [diff] [blame] | 828 | } |
| 829 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 830 | /// \brief Determine whether ')' is ending a cast. |
| 831 | bool rParenEndsCast(const FormatToken &Tok) { |
| 832 | FormatToken *LeftOfParens = NULL; |
| 833 | if (Tok.MatchingParen) |
| 834 | LeftOfParens = Tok.MatchingParen->getPreviousNonComment(); |
| 835 | bool IsCast = false; |
| 836 | bool ParensAreEmpty = Tok.Previous == Tok.MatchingParen; |
| 837 | bool ParensAreType = !Tok.Previous || |
| 838 | Tok.Previous->Type == TT_PointerOrReference || |
| 839 | Tok.Previous->Type == TT_TemplateCloser || |
| 840 | Tok.Previous->isSimpleTypeSpecifier(); |
| 841 | bool ParensCouldEndDecl = |
| 842 | Tok.Next && Tok.Next->isOneOf(tok::equal, tok::semi, tok::l_brace); |
| 843 | bool IsSizeOfOrAlignOf = |
| 844 | LeftOfParens && LeftOfParens->isOneOf(tok::kw_sizeof, tok::kw_alignof); |
| 845 | if (ParensAreType && !ParensCouldEndDecl && !IsSizeOfOrAlignOf && |
| 846 | ((Contexts.size() > 1 && Contexts[Contexts.size() - 2].IsExpression) || |
| 847 | (Tok.Next && Tok.Next->isBinaryOperator()))) |
| 848 | IsCast = true; |
| 849 | else if (Tok.Next && Tok.Next->isNot(tok::string_literal) && |
| 850 | (Tok.Next->Tok.isLiteral() || |
| 851 | Tok.Next->isOneOf(tok::kw_sizeof, tok::kw_alignof))) |
| 852 | IsCast = true; |
| 853 | // If there is an identifier after the (), it is likely a cast, unless |
| 854 | // there is also an identifier before the (). |
| 855 | else if (LeftOfParens && (LeftOfParens->Tok.getIdentifierInfo() == NULL || |
| 856 | LeftOfParens->is(tok::kw_return)) && |
| 857 | LeftOfParens->Type != TT_OverloadedOperator && |
| 858 | LeftOfParens->isNot(tok::at) && |
| 859 | LeftOfParens->Type != TT_TemplateCloser && Tok.Next) { |
| 860 | if (Tok.Next->isOneOf(tok::identifier, tok::numeric_constant)) { |
| 861 | IsCast = true; |
| 862 | } else { |
| 863 | // Use heuristics to recognize c style casting. |
| 864 | FormatToken *Prev = Tok.Previous; |
| 865 | if (Prev && Prev->isOneOf(tok::amp, tok::star)) |
| 866 | Prev = Prev->Previous; |
| 867 | |
| 868 | if (Prev && Tok.Next && Tok.Next->Next) { |
| 869 | bool NextIsUnary = Tok.Next->isUnaryOperator() || |
| 870 | Tok.Next->isOneOf(tok::amp, tok::star); |
| 871 | IsCast = NextIsUnary && Tok.Next->Next->isOneOf( |
| 872 | tok::identifier, tok::numeric_constant); |
| 873 | } |
| 874 | |
| 875 | for (; Prev != Tok.MatchingParen; Prev = Prev->Previous) { |
| 876 | if (!Prev || !Prev->isOneOf(tok::kw_const, tok::identifier)) { |
| 877 | IsCast = false; |
| 878 | break; |
| 879 | } |
| 880 | } |
| 881 | } |
| 882 | } |
| 883 | return IsCast && !ParensAreEmpty; |
| 884 | } |
| 885 | |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 886 | /// \brief Return the type of the given token assuming it is * or &. |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 887 | TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression, |
| 888 | bool InTemplateArgument) { |
Alexander Kornienko | 0bdc643 | 2013-07-04 14:47:51 +0000 | [diff] [blame] | 889 | const FormatToken *PrevToken = Tok.getPreviousNonComment(); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 890 | if (!PrevToken) |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 891 | return TT_UnaryOperator; |
| 892 | |
Alexander Kornienko | 0bdc643 | 2013-07-04 14:47:51 +0000 | [diff] [blame] | 893 | const FormatToken *NextToken = Tok.getNextNonComment(); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 894 | if (!NextToken) |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 895 | return TT_Unknown; |
| 896 | |
Daniel Jasper | 431f591 | 2013-05-28 08:33:00 +0000 | [diff] [blame] | 897 | if (PrevToken->is(tok::coloncolon) || |
| 898 | (PrevToken->is(tok::l_paren) && !IsExpression)) |
Daniel Jasper | 8a5d7cd | 2013-03-01 17:13:29 +0000 | [diff] [blame] | 899 | return TT_PointerOrReference; |
| 900 | |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 901 | if (PrevToken->isOneOf(tok::l_paren, tok::l_square, tok::l_brace, |
Daniel Jasper | d3cf17b | 2013-03-14 10:50:25 +0000 | [diff] [blame] | 902 | tok::comma, tok::semi, tok::kw_return, tok::colon, |
Daniel Jasper | 65da8e9 | 2013-09-21 17:31:51 +0000 | [diff] [blame] | 903 | tok::equal, tok::kw_delete, tok::kw_sizeof) || |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 904 | PrevToken->Type == TT_BinaryOperator || |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 905 | PrevToken->Type == TT_ConditionalExpr || |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 906 | PrevToken->Type == TT_UnaryOperator || PrevToken->Type == TT_CastRParen) |
| 907 | return TT_UnaryOperator; |
| 908 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 909 | if (NextToken->is(tok::l_square) && NextToken->Type != TT_LambdaLSquare) |
Nico Weber | e8a9798 | 2013-02-06 06:20:11 +0000 | [diff] [blame] | 910 | return TT_PointerOrReference; |
| 911 | |
Daniel Jasper | db8afe4 | 2013-09-10 10:26:38 +0000 | [diff] [blame] | 912 | if (PrevToken->is(tok::r_paren) && PrevToken->MatchingParen && |
| 913 | PrevToken->MatchingParen->Previous && |
| 914 | PrevToken->MatchingParen->Previous->is(tok::kw_typeof)) |
| 915 | return TT_PointerOrReference; |
| 916 | |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 917 | if (PrevToken->Tok.isLiteral() || |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 918 | PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::kw_true, |
| 919 | tok::kw_false) || |
| 920 | NextToken->Tok.isLiteral() || |
| 921 | NextToken->isOneOf(tok::kw_true, tok::kw_false) || |
| 922 | NextToken->isUnaryOperator() || |
| 923 | // If we know we're in a template argument, there are no named |
| 924 | // declarations. Thus, having an identifier on the right-hand side |
| 925 | // indicates a binary operator. |
| 926 | (InTemplateArgument && NextToken->Tok.isAnyIdentifier())) |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 927 | return TT_BinaryOperator; |
| 928 | |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 929 | // It is very unlikely that we are going to find a pointer or reference type |
| 930 | // definition on the RHS of an assignment. |
| 931 | if (IsExpression) |
| 932 | return TT_BinaryOperator; |
| 933 | |
| 934 | return TT_PointerOrReference; |
| 935 | } |
| 936 | |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 937 | TokenType determinePlusMinusCaretUsage(const FormatToken &Tok) { |
Alexander Kornienko | 0bdc643 | 2013-07-04 14:47:51 +0000 | [diff] [blame] | 938 | const FormatToken *PrevToken = Tok.getPreviousNonComment(); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 939 | if (!PrevToken || PrevToken->Type == TT_CastRParen) |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 940 | return TT_UnaryOperator; |
| 941 | |
| 942 | // Use heuristics to recognize unary operators. |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 943 | if (PrevToken->isOneOf(tok::equal, tok::l_paren, tok::comma, tok::l_square, |
| 944 | tok::question, tok::colon, tok::kw_return, |
| 945 | tok::kw_case, tok::at, tok::l_brace)) |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 946 | return TT_UnaryOperator; |
| 947 | |
Nico Weber | ee0feec | 2013-02-05 16:21:00 +0000 | [diff] [blame] | 948 | // There can't be two consecutive binary operators. |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 949 | if (PrevToken->Type == TT_BinaryOperator) |
| 950 | return TT_UnaryOperator; |
| 951 | |
| 952 | // Fall back to marking the token as binary operator. |
| 953 | return TT_BinaryOperator; |
| 954 | } |
| 955 | |
| 956 | /// \brief Determine whether ++/-- are pre- or post-increments/-decrements. |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 957 | TokenType determineIncrementUsage(const FormatToken &Tok) { |
Alexander Kornienko | 0bdc643 | 2013-07-04 14:47:51 +0000 | [diff] [blame] | 958 | const FormatToken *PrevToken = Tok.getPreviousNonComment(); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 959 | if (!PrevToken || PrevToken->Type == TT_CastRParen) |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 960 | return TT_UnaryOperator; |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 961 | if (PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::identifier)) |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 962 | return TT_TrailingUnaryOperator; |
| 963 | |
| 964 | return TT_UnaryOperator; |
| 965 | } |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 966 | |
| 967 | SmallVector<Context, 8> Contexts; |
| 968 | |
Daniel Jasper | d4a03db | 2013-08-22 15:00:41 +0000 | [diff] [blame] | 969 | const FormatStyle &Style; |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 970 | AnnotatedLine &Line; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 971 | FormatToken *CurrentToken; |
Daniel Jasper | 4e77809 | 2013-02-06 10:05:46 +0000 | [diff] [blame] | 972 | bool KeywordVirtualFound; |
Daniel Jasper | 2ca3741 | 2013-07-09 14:36:48 +0000 | [diff] [blame] | 973 | bool AutoFound; |
Nico Weber | c2e6d2a | 2013-02-11 15:32:15 +0000 | [diff] [blame] | 974 | IdentifierInfo &Ident_in; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 975 | }; |
| 976 | |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 977 | static int PrecedenceUnaryOperator = prec::PointerToMember + 1; |
| 978 | static int PrecedenceArrowAndPeriod = prec::PointerToMember + 2; |
| 979 | |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 980 | /// \brief Parses binary expressions by inserting fake parenthesis based on |
| 981 | /// operator precedence. |
| 982 | class ExpressionParser { |
| 983 | public: |
Daniel Jasper | 9acb8b4 | 2013-06-06 09:11:58 +0000 | [diff] [blame] | 984 | ExpressionParser(AnnotatedLine &Line) : Current(Line.First) { |
| 985 | // Skip leading "}", e.g. in "} else if (...) {". |
| 986 | if (Current->is(tok::r_brace)) |
| 987 | next(); |
| 988 | } |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 989 | |
| 990 | /// \brief Parse expressions with the given operatore precedence. |
Daniel Jasper | 237d4c1 | 2013-02-23 21:01:55 +0000 | [diff] [blame] | 991 | void parse(int Precedence = 0) { |
Daniel Jasper | 966e6d3 | 2013-11-07 19:23:49 +0000 | [diff] [blame] | 992 | // Skip 'return' and ObjC selector colons as they are not part of a binary |
| 993 | // expression. |
| 994 | while (Current && |
| 995 | (Current->is(tok::kw_return) || |
| 996 | (Current->is(tok::colon) && Current->Type == TT_ObjCMethodExpr))) |
Daniel Jasper | f78bf4a | 2013-09-30 08:29:03 +0000 | [diff] [blame] | 997 | next(); |
| 998 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 999 | if (!Current || Precedence > PrecedenceArrowAndPeriod) |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1000 | return; |
| 1001 | |
Daniel Jasper | c01897c | 2013-05-31 14:56:12 +0000 | [diff] [blame] | 1002 | // Conditional expressions need to be parsed separately for proper nesting. |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1003 | if (Precedence == prec::Conditional) { |
Daniel Jasper | c01897c | 2013-05-31 14:56:12 +0000 | [diff] [blame] | 1004 | parseConditionalExpr(); |
| 1005 | return; |
| 1006 | } |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1007 | |
| 1008 | // Parse unary operators, which all have a higher precedence than binary |
| 1009 | // operators. |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1010 | if (Precedence == PrecedenceUnaryOperator) { |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1011 | parseUnaryOperator(); |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1012 | return; |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1013 | } |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1014 | |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1015 | FormatToken *Start = Current; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1016 | FormatToken *LatestOperator = nullptr; |
| 1017 | unsigned OperatorIndex = 0; |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1018 | |
Daniel Jasper | 237d4c1 | 2013-02-23 21:01:55 +0000 | [diff] [blame] | 1019 | while (Current) { |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1020 | // Consume operators with higher precedence. |
Daniel Jasper | bf71ba2 | 2013-04-08 20:33:42 +0000 | [diff] [blame] | 1021 | parse(Precedence + 1); |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1022 | |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1023 | int CurrentPrecedence = getCurrentPrecedence(); |
| 1024 | |
| 1025 | if (Current && Current->Type == TT_ObjCSelectorName && |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1026 | Precedence == CurrentPrecedence) { |
| 1027 | if (LatestOperator) |
| 1028 | addFakeParenthesis(Start, prec::Level(Precedence)); |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1029 | Start = Current; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1030 | } |
Daniel Jasper | 237d4c1 | 2013-02-23 21:01:55 +0000 | [diff] [blame] | 1031 | |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1032 | // At the end of the line or when an operator with higher precedence is |
| 1033 | // found, insert fake parenthesis and return. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1034 | if (!Current || Current->closesScope() || |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1035 | (CurrentPrecedence != -1 && CurrentPrecedence < Precedence)) { |
| 1036 | if (LatestOperator) { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1037 | LatestOperator->LastOperator = true; |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1038 | if (Precedence == PrecedenceArrowAndPeriod) { |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1039 | // Call expressions don't have a binary operator precedence. |
| 1040 | addFakeParenthesis(Start, prec::Unknown); |
| 1041 | } else { |
| 1042 | addFakeParenthesis(Start, prec::Level(Precedence)); |
| 1043 | } |
| 1044 | } |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1045 | return; |
| 1046 | } |
| 1047 | |
| 1048 | // Consume scopes: (), [], <> and {} |
Daniel Jasper | ac3223e | 2013-04-10 09:49:49 +0000 | [diff] [blame] | 1049 | if (Current->opensScope()) { |
| 1050 | while (Current && !Current->closesScope()) { |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1051 | next(); |
| 1052 | parse(); |
| 1053 | } |
| 1054 | next(); |
| 1055 | } else { |
| 1056 | // Operator found. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1057 | if (CurrentPrecedence == Precedence) { |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1058 | LatestOperator = Current; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1059 | Current->OperatorIndex = OperatorIndex; |
| 1060 | ++OperatorIndex; |
| 1061 | } |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1062 | |
| 1063 | next(); |
| 1064 | } |
| 1065 | } |
| 1066 | } |
| 1067 | |
| 1068 | private: |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1069 | /// \brief Gets the precedence (+1) of the given token for binary operators |
| 1070 | /// and other tokens that we treat like binary operators. |
| 1071 | int getCurrentPrecedence() { |
| 1072 | if (Current) { |
| 1073 | if (Current->Type == TT_ConditionalExpr) |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1074 | return prec::Conditional; |
Daniel Jasper | 966e6d3 | 2013-11-07 19:23:49 +0000 | [diff] [blame] | 1075 | else if (Current->is(tok::semi) || Current->Type == TT_InlineASMColon || |
| 1076 | Current->Type == TT_ObjCSelectorName) |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1077 | return 0; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1078 | else if (Current->Type == TT_RangeBasedForLoopColon) |
| 1079 | return prec::Comma; |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1080 | else if (Current->Type == TT_BinaryOperator || Current->is(tok::comma)) |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1081 | return Current->getPrecedence(); |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1082 | else if (Current->isOneOf(tok::period, tok::arrow)) |
| 1083 | return PrecedenceArrowAndPeriod; |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1084 | } |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1085 | return -1; |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1086 | } |
| 1087 | |
Daniel Jasper | c01897c | 2013-05-31 14:56:12 +0000 | [diff] [blame] | 1088 | void addFakeParenthesis(FormatToken *Start, prec::Level Precedence) { |
| 1089 | Start->FakeLParens.push_back(Precedence); |
Daniel Jasper | db4813a | 2013-09-06 08:08:14 +0000 | [diff] [blame] | 1090 | if (Precedence > prec::Unknown) |
| 1091 | Start->StartsBinaryExpression = true; |
| 1092 | if (Current) { |
Daniel Jasper | c01897c | 2013-05-31 14:56:12 +0000 | [diff] [blame] | 1093 | ++Current->Previous->FakeRParens; |
Daniel Jasper | db4813a | 2013-09-06 08:08:14 +0000 | [diff] [blame] | 1094 | if (Precedence > prec::Unknown) |
| 1095 | Current->Previous->EndsBinaryExpression = true; |
| 1096 | } |
Daniel Jasper | c01897c | 2013-05-31 14:56:12 +0000 | [diff] [blame] | 1097 | } |
| 1098 | |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1099 | /// \brief Parse unary operator expressions and surround them with fake |
| 1100 | /// parentheses if appropriate. |
| 1101 | void parseUnaryOperator() { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1102 | if (!Current || Current->Type != TT_UnaryOperator) { |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1103 | parse(PrecedenceArrowAndPeriod); |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1104 | return; |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1105 | } |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1106 | |
| 1107 | FormatToken *Start = Current; |
| 1108 | next(); |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1109 | parseUnaryOperator(); |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1110 | |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1111 | // The actual precedence doesn't matter. |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1112 | addFakeParenthesis(Start, prec::Unknown); |
Daniel Jasper | 3618e6f | 2013-08-23 15:14:03 +0000 | [diff] [blame] | 1113 | } |
| 1114 | |
Daniel Jasper | c01897c | 2013-05-31 14:56:12 +0000 | [diff] [blame] | 1115 | void parseConditionalExpr() { |
| 1116 | FormatToken *Start = Current; |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1117 | parse(prec::LogicalOr); |
Daniel Jasper | c01897c | 2013-05-31 14:56:12 +0000 | [diff] [blame] | 1118 | if (!Current || !Current->is(tok::question)) |
| 1119 | return; |
| 1120 | next(); |
Daniel Jasper | d489f8c | 2013-08-27 11:09:05 +0000 | [diff] [blame] | 1121 | parse(prec::LogicalOr); |
Daniel Jasper | c01897c | 2013-05-31 14:56:12 +0000 | [diff] [blame] | 1122 | if (!Current || Current->Type != TT_ConditionalExpr) |
| 1123 | return; |
| 1124 | next(); |
| 1125 | parseConditionalExpr(); |
| 1126 | addFakeParenthesis(Start, prec::Conditional); |
| 1127 | } |
| 1128 | |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1129 | void next() { |
Alexander Kornienko | d71b15b | 2013-06-17 13:19:53 +0000 | [diff] [blame] | 1130 | if (Current) |
| 1131 | Current = Current->Next; |
| 1132 | while (Current && Current->isTrailingComment()) |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1133 | Current = Current->Next; |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1134 | } |
| 1135 | |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1136 | FormatToken *Current; |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1137 | }; |
| 1138 | |
Craig Topper | 14e6649 | 2013-07-01 04:03:19 +0000 | [diff] [blame] | 1139 | } // end anonymous namespace |
| 1140 | |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 1141 | void |
| 1142 | TokenAnnotator::setCommentLineLevels(SmallVectorImpl<AnnotatedLine *> &Lines) { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1143 | const AnnotatedLine *NextNonCommentLine = nullptr; |
Daniel Jasper | 2a80ad6 | 2013-11-05 19:10:03 +0000 | [diff] [blame] | 1144 | for (SmallVectorImpl<AnnotatedLine *>::reverse_iterator I = Lines.rbegin(), |
| 1145 | E = Lines.rend(); |
| 1146 | I != E; ++I) { |
| 1147 | if (NextNonCommentLine && (*I)->First->is(tok::comment) && |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1148 | (*I)->First->Next == nullptr) |
Daniel Jasper | 2a80ad6 | 2013-11-05 19:10:03 +0000 | [diff] [blame] | 1149 | (*I)->Level = NextNonCommentLine->Level; |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 1150 | else |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1151 | NextNonCommentLine = (*I)->First->isNot(tok::r_brace) ? (*I) : nullptr; |
Daniel Jasper | 2a80ad6 | 2013-11-05 19:10:03 +0000 | [diff] [blame] | 1152 | |
| 1153 | setCommentLineLevels((*I)->Children); |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 1154 | } |
| 1155 | } |
| 1156 | |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 1157 | void TokenAnnotator::annotate(AnnotatedLine &Line) { |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 1158 | for (SmallVectorImpl<AnnotatedLine *>::iterator I = Line.Children.begin(), |
| 1159 | E = Line.Children.end(); |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1160 | I != E; ++I) { |
| 1161 | annotate(**I); |
| 1162 | } |
Daniel Jasper | d4a03db | 2013-08-22 15:00:41 +0000 | [diff] [blame] | 1163 | AnnotatingParser Parser(Style, Line, Ident_in); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1164 | Line.Type = Parser.parseLine(); |
| 1165 | if (Line.Type == LT_Invalid) |
| 1166 | return; |
| 1167 | |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1168 | ExpressionParser ExprParser(Line); |
| 1169 | ExprParser.parse(); |
| 1170 | |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1171 | if (Line.First->Type == TT_ObjCMethodSpecifier) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1172 | Line.Type = LT_ObjCMethodDecl; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1173 | else if (Line.First->Type == TT_ObjCDecl) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1174 | Line.Type = LT_ObjCDecl; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1175 | else if (Line.First->Type == TT_ObjCProperty) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1176 | Line.Type = LT_ObjCProperty; |
| 1177 | |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1178 | Line.First->SpacesRequiredBefore = 1; |
| 1179 | Line.First->CanBreakBefore = Line.First->MustBreakBefore; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1180 | } |
| 1181 | |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 1182 | void TokenAnnotator::calculateFormattingInformation(AnnotatedLine &Line) { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1183 | for (SmallVectorImpl<AnnotatedLine *>::iterator I = Line.Children.begin(), |
| 1184 | E = Line.Children.end(); |
| 1185 | I != E; ++I) { |
| 1186 | calculateFormattingInformation(**I); |
| 1187 | } |
| 1188 | |
Alexander Kornienko | 83a7dcd | 2013-09-10 09:38:25 +0000 | [diff] [blame] | 1189 | Line.First->TotalLength = |
| 1190 | Line.First->IsMultiline ? Style.ColumnLimit : Line.First->ColumnWidth; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1191 | if (!Line.First->Next) |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 1192 | return; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1193 | FormatToken *Current = Line.First->Next; |
Daniel Jasper | dbfb5f3 | 2013-11-07 17:52:51 +0000 | [diff] [blame] | 1194 | bool InFunctionDecl = Line.MightBeFunctionDecl; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1195 | while (Current) { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1196 | if (Current->Type == TT_LineComment) { |
| 1197 | if (Current->Previous->BlockKind == BK_BracedInit && |
| 1198 | Current->Previous->opensScope()) |
| 1199 | Current->SpacesRequiredBefore = Style.Cpp11BracedListStyle ? 0 : 1; |
| 1200 | else |
| 1201 | Current->SpacesRequiredBefore = Style.SpacesBeforeTrailingComments; |
| 1202 | |
| 1203 | // If we find a trailing comment, iterate backwards to determine whether |
| 1204 | // it seems to relate to a specific parameter. If so, break before that |
| 1205 | // parameter to avoid changing the comment's meaning. E.g. don't move 'b' |
| 1206 | // to the previous line in: |
| 1207 | // SomeFunction(a, |
| 1208 | // b, // comment |
| 1209 | // c); |
| 1210 | if (!Current->HasUnescapedNewline) { |
| 1211 | for (FormatToken *Parameter = Current->Previous; Parameter; |
| 1212 | Parameter = Parameter->Previous) { |
| 1213 | if (Parameter->isOneOf(tok::comment, tok::r_brace)) |
| 1214 | break; |
| 1215 | if (Parameter->Previous && Parameter->Previous->is(tok::comma)) { |
| 1216 | if (Parameter->Previous->Type != TT_CtorInitializerComma && |
| 1217 | Parameter->HasUnescapedNewline) |
| 1218 | Parameter->MustBreakBefore = true; |
| 1219 | break; |
| 1220 | } |
| 1221 | } |
| 1222 | } |
| 1223 | } else if (Current->SpacesRequiredBefore == 0 && |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1224 | spaceRequiredBefore(Line, *Current)) { |
Alexander Kornienko | b18c258 | 2013-10-11 21:43:05 +0000 | [diff] [blame] | 1225 | Current->SpacesRequiredBefore = 1; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1226 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1227 | |
Daniel Jasper | ebaa171 | 2013-09-17 09:52:48 +0000 | [diff] [blame] | 1228 | Current->MustBreakBefore = |
| 1229 | Current->MustBreakBefore || mustBreakBefore(Line, *Current); |
| 1230 | |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 1231 | Current->CanBreakBefore = |
| 1232 | Current->MustBreakBefore || canBreakBefore(Line, *Current); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1233 | unsigned ChildSize = 0; |
| 1234 | if (Current->Previous->Children.size() == 1) { |
| 1235 | FormatToken &LastOfChild = *Current->Previous->Children[0]->Last; |
| 1236 | ChildSize = LastOfChild.isTrailingComment() ? Style.ColumnLimit |
| 1237 | : LastOfChild.TotalLength + 1; |
| 1238 | } |
| 1239 | if (Current->MustBreakBefore || Current->Previous->Children.size() > 1 || |
Alexander Kornienko | 83a7dcd | 2013-09-10 09:38:25 +0000 | [diff] [blame] | 1240 | Current->IsMultiline) |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1241 | Current->TotalLength = Current->Previous->TotalLength + Style.ColumnLimit; |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 1242 | else |
Daniel Jasper | 2a409b6 | 2013-07-08 14:34:09 +0000 | [diff] [blame] | 1243 | Current->TotalLength = Current->Previous->TotalLength + |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1244 | Current->ColumnWidth + ChildSize + |
Daniel Jasper | 2a409b6 | 2013-07-08 14:34:09 +0000 | [diff] [blame] | 1245 | Current->SpacesRequiredBefore; |
Daniel Jasper | dbfb5f3 | 2013-11-07 17:52:51 +0000 | [diff] [blame] | 1246 | |
| 1247 | if (Current->Type == TT_CtorInitializerColon) |
| 1248 | InFunctionDecl = false; |
| 1249 | |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 1250 | // FIXME: Only calculate this if CanBreakBefore is true once static |
| 1251 | // initializers etc. are sorted out. |
| 1252 | // FIXME: Move magic numbers to a better place. |
Daniel Jasper | dbfb5f3 | 2013-11-07 17:52:51 +0000 | [diff] [blame] | 1253 | Current->SplitPenalty = 20 * Current->BindingStrength + |
| 1254 | splitPenalty(Line, *Current, InFunctionDecl); |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 1255 | |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1256 | Current = Current->Next; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1257 | } |
Daniel Jasper | bf71ba2 | 2013-04-08 20:33:42 +0000 | [diff] [blame] | 1258 | |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 1259 | calculateUnbreakableTailLengths(Line); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1260 | for (Current = Line.First; Current != nullptr; Current = Current->Next) { |
Daniel Jasper | d4a03db | 2013-08-22 15:00:41 +0000 | [diff] [blame] | 1261 | if (Current->Role) |
| 1262 | Current->Role->precomputeFormattingInfos(Current); |
| 1263 | } |
| 1264 | |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1265 | DEBUG({ printDebugInfo(Line); }); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1266 | } |
| 1267 | |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 1268 | void TokenAnnotator::calculateUnbreakableTailLengths(AnnotatedLine &Line) { |
| 1269 | unsigned UnbreakableTailLength = 0; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1270 | FormatToken *Current = Line.Last; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1271 | while (Current) { |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 1272 | Current->UnbreakableTailLength = UnbreakableTailLength; |
| 1273 | if (Current->CanBreakBefore || |
| 1274 | Current->isOneOf(tok::comment, tok::string_literal)) { |
| 1275 | UnbreakableTailLength = 0; |
| 1276 | } else { |
| 1277 | UnbreakableTailLength += |
Alexander Kornienko | 83a7dcd | 2013-09-10 09:38:25 +0000 | [diff] [blame] | 1278 | Current->ColumnWidth + Current->SpacesRequiredBefore; |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 1279 | } |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1280 | Current = Current->Previous; |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 1281 | } |
| 1282 | } |
| 1283 | |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 1284 | unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line, |
Daniel Jasper | dbfb5f3 | 2013-11-07 17:52:51 +0000 | [diff] [blame] | 1285 | const FormatToken &Tok, |
| 1286 | bool InFunctionDecl) { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1287 | const FormatToken &Left = *Tok.Previous; |
| 1288 | const FormatToken &Right = Tok; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1289 | |
Daniel Jasper | 5ad390d | 2013-05-28 11:30:49 +0000 | [diff] [blame] | 1290 | if (Left.is(tok::semi)) |
| 1291 | return 0; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1292 | if (Left.is(tok::comma) || (Right.is(tok::identifier) && Right.Next && |
| 1293 | Right.Next->Type == TT_DictLiteral)) |
Daniel Jasper | 5ad390d | 2013-05-28 11:30:49 +0000 | [diff] [blame] | 1294 | return 1; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1295 | if (Right.is(tok::l_square)) { |
| 1296 | if (Style.Language == FormatStyle::LK_Proto) |
| 1297 | return 1; |
| 1298 | if (Right.Type != TT_ObjCMethodExpr) |
| 1299 | return 250; |
| 1300 | } |
Daniel Jasper | 6561f6a | 2013-07-09 07:43:55 +0000 | [diff] [blame] | 1301 | if (Right.Type == TT_StartOfName || Right.is(tok::kw_operator)) { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1302 | if (Line.First->is(tok::kw_for) && Right.PartOfMultiVariableDeclStmt) |
Daniel Jasper | 3c08a81 | 2013-02-24 18:54:32 +0000 | [diff] [blame] | 1303 | return 3; |
Daniel Jasper | c18cff3 | 2013-07-11 12:34:23 +0000 | [diff] [blame] | 1304 | if (Left.Type == TT_StartOfName) |
| 1305 | return 20; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1306 | if (InFunctionDecl && Right.NestingLevel == 0) |
Daniel Jasper | 3c08a81 | 2013-02-24 18:54:32 +0000 | [diff] [blame] | 1307 | return Style.PenaltyReturnTypeOnItsOwnLine; |
Daniel Jasper | 92495a8 | 2013-08-19 10:16:18 +0000 | [diff] [blame] | 1308 | return 200; |
Daniel Jasper | 3c08a81 | 2013-02-24 18:54:32 +0000 | [diff] [blame] | 1309 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1310 | if (Left.is(tok::equal) && Right.is(tok::l_brace)) |
| 1311 | return 150; |
Daniel Jasper | 198c8bf | 2013-07-05 07:58:34 +0000 | [diff] [blame] | 1312 | if (Left.Type == TT_CastRParen) |
| 1313 | return 100; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1314 | if (Left.is(tok::coloncolon) || |
| 1315 | (Right.is(tok::period) && Style.Language == FormatStyle::LK_Proto)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1316 | return 500; |
Daniel Jasper | 6b119d6 | 2013-04-05 17:22:09 +0000 | [diff] [blame] | 1317 | if (Left.isOneOf(tok::kw_class, tok::kw_struct)) |
| 1318 | return 5000; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1319 | |
Daniel Jasper | 6cabab4 | 2013-02-14 08:42:54 +0000 | [diff] [blame] | 1320 | if (Left.Type == TT_RangeBasedForLoopColon || |
| 1321 | Left.Type == TT_InheritanceColon) |
Daniel Jasper | 84a1a63 | 2013-02-26 13:18:08 +0000 | [diff] [blame] | 1322 | return 2; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1323 | |
Daniel Jasper | d3fef0f | 2013-08-27 14:24:43 +0000 | [diff] [blame] | 1324 | if (Right.isMemberAccess()) { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1325 | if (Left.is(tok::r_paren) && Left.MatchingParen && |
Daniel Jasper | 2f0a020 | 2013-09-06 08:54:24 +0000 | [diff] [blame] | 1326 | Left.MatchingParen->ParameterCount > 0) |
Daniel Jasper | 518ee34 | 2013-02-26 13:59:14 +0000 | [diff] [blame] | 1327 | return 20; // Should be smaller than breaking at a nested comma. |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1328 | return 150; |
| 1329 | } |
| 1330 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1331 | if (Right.Type == TT_TrailingAnnotation && Right.Next && |
| 1332 | Right.Next->isNot(tok::l_paren)) { |
| 1333 | // Generally, breaking before a trailing annotation is bad unless it is |
| 1334 | // function-like. It seems to be especially preferable to keep standard |
| 1335 | // annotations (i.e. "const", "final" and "override") on the same line. |
| 1336 | // Use a slightly higher penalty after ")" so that annotations like |
| 1337 | // "const override" are kept together. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1338 | bool is_short_annotation = Right.TokenText.size() < 10; |
| 1339 | return (Left.is(tok::r_paren) ? 100 : 120) + (is_short_annotation ? 50 : 0); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1340 | } |
Daniel Jasper | 5ad72bb | 2013-05-22 08:28:26 +0000 | [diff] [blame] | 1341 | |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1342 | // In for-loops, prefer breaking at ',' and ';'. |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1343 | if (Line.First->is(tok::kw_for) && Left.is(tok::equal)) |
Daniel Jasper | 7d81281 | 2013-02-21 15:00:29 +0000 | [diff] [blame] | 1344 | return 4; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1345 | |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1346 | // In Objective-C method expressions, prefer breaking before "param:" over |
| 1347 | // breaking after it. |
Daniel Jasper | 63d7ced | 2013-02-05 10:07:47 +0000 | [diff] [blame] | 1348 | if (Right.Type == TT_ObjCSelectorName) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1349 | return 0; |
Daniel Jasper | 63d7ced | 2013-02-05 10:07:47 +0000 | [diff] [blame] | 1350 | if (Left.is(tok::colon) && Left.Type == TT_ObjCMethodExpr) |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1351 | return Line.MightBeFunctionDecl ? 50 : 500; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1352 | |
Daniel Jasper | dbfb5f3 | 2013-11-07 17:52:51 +0000 | [diff] [blame] | 1353 | if (Left.is(tok::l_paren) && InFunctionDecl) |
Daniel Jasper | 1407bee | 2013-04-11 14:29:13 +0000 | [diff] [blame] | 1354 | return 100; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1355 | if (Left.is(tok::equal) && InFunctionDecl) |
| 1356 | return 110; |
Daniel Jasper | ac3223e | 2013-04-10 09:49:49 +0000 | [diff] [blame] | 1357 | if (Left.opensScope()) |
Daniel Jasper | 47066e4 | 2013-10-25 14:29:37 +0000 | [diff] [blame] | 1358 | return Left.ParameterCount > 1 ? Style.PenaltyBreakBeforeFirstCallParameter |
| 1359 | : 19; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1360 | |
Daniel Jasper | 4e8a7b4 | 2013-02-06 21:04:05 +0000 | [diff] [blame] | 1361 | if (Right.is(tok::lessless)) { |
| 1362 | if (Left.is(tok::string_literal)) { |
Alexander Kornienko | 0089510 | 2013-06-05 14:09:10 +0000 | [diff] [blame] | 1363 | StringRef Content = Left.TokenText; |
Daniel Jasper | 2037698 | 2013-09-29 12:02:57 +0000 | [diff] [blame] | 1364 | if (Content.startswith("\"")) |
| 1365 | Content = Content.drop_front(1); |
| 1366 | if (Content.endswith("\"")) |
| 1367 | Content = Content.drop_back(1); |
| 1368 | Content = Content.trim(); |
Daniel Jasper | bfa1edd | 2013-03-14 14:00:17 +0000 | [diff] [blame] | 1369 | if (Content.size() > 1 && |
| 1370 | (Content.back() == ':' || Content.back() == '=')) |
Daniel Jasper | 9637dda | 2013-07-15 14:33:14 +0000 | [diff] [blame] | 1371 | return 25; |
Daniel Jasper | 4e8a7b4 | 2013-02-06 21:04:05 +0000 | [diff] [blame] | 1372 | } |
Daniel Jasper | 0c36878 | 2013-07-15 15:04:42 +0000 | [diff] [blame] | 1373 | return 1; // Breaking at a << is really cheap. |
Daniel Jasper | 4e8a7b4 | 2013-02-06 21:04:05 +0000 | [diff] [blame] | 1374 | } |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1375 | if (Left.Type == TT_ConditionalExpr) |
Daniel Jasper | 518ee34 | 2013-02-26 13:59:14 +0000 | [diff] [blame] | 1376 | return prec::Conditional; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1377 | prec::Level Level = Left.getPrecedence(); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1378 | |
| 1379 | if (Level != prec::Unknown) |
| 1380 | return Level; |
Daniel Jasper | 2484971 | 2013-03-01 16:48:32 +0000 | [diff] [blame] | 1381 | |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1382 | return 3; |
| 1383 | } |
| 1384 | |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 1385 | bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line, |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1386 | const FormatToken &Left, |
| 1387 | const FormatToken &Right) { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1388 | if (Style.Language == FormatStyle::LK_Proto) { |
| 1389 | if (Right.is(tok::l_paren) && |
| 1390 | (Left.TokenText == "returns" || Left.TokenText == "option")) |
| 1391 | return true; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1392 | } else if (Style.Language == FormatStyle::LK_JavaScript) { |
| 1393 | if (Left.TokenText == "var") |
| 1394 | return true; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1395 | } |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1396 | if (Left.is(tok::kw_return) && Right.isNot(tok::semi)) |
| 1397 | return true; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1398 | if (Style.ObjCSpaceAfterProperty && Line.Type == LT_ObjCProperty && |
| 1399 | Left.Tok.getObjCKeywordID() == tok::objc_property) |
| 1400 | return true; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1401 | if (Right.is(tok::hashhash)) |
| 1402 | return Left.is(tok::hash); |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 1403 | if (Left.isOneOf(tok::hashhash, tok::hash)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1404 | return Right.is(tok::hash); |
Daniel Jasper | 7df56bf | 2013-08-20 12:36:34 +0000 | [diff] [blame] | 1405 | if (Left.is(tok::l_paren) && Right.is(tok::r_paren)) |
| 1406 | return Style.SpaceInEmptyParentheses; |
| 1407 | if (Left.is(tok::l_paren) || Right.is(tok::r_paren)) |
Daniel Jasper | 34f3d05 | 2013-08-21 08:39:01 +0000 | [diff] [blame] | 1408 | return (Right.Type == TT_CastRParen || |
| 1409 | (Left.MatchingParen && Left.MatchingParen->Type == TT_CastRParen)) |
Daniel Jasper | 7df56bf | 2013-08-20 12:36:34 +0000 | [diff] [blame] | 1410 | ? Style.SpacesInCStyleCastParentheses |
| 1411 | : Style.SpacesInParentheses; |
Daniel Jasper | d8ee5c1 | 2013-10-29 14:52:02 +0000 | [diff] [blame] | 1412 | if (Style.SpacesInAngles && |
| 1413 | ((Left.Type == TT_TemplateOpener) != (Right.Type == TT_TemplateCloser))) |
| 1414 | return true; |
Daniel Jasper | 7df56bf | 2013-08-20 12:36:34 +0000 | [diff] [blame] | 1415 | if (Right.isOneOf(tok::semi, tok::comma)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1416 | return false; |
| 1417 | if (Right.is(tok::less) && |
| 1418 | (Left.is(tok::kw_template) || |
| 1419 | (Line.Type == LT_ObjCDecl && Style.ObjCSpaceBeforeProtocolList))) |
| 1420 | return true; |
| 1421 | if (Left.is(tok::arrow) || Right.is(tok::arrow)) |
| 1422 | return false; |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 1423 | if (Left.isOneOf(tok::exclaim, tok::tilde)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1424 | return false; |
| 1425 | if (Left.is(tok::at) && |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 1426 | Right.isOneOf(tok::identifier, tok::string_literal, tok::char_constant, |
| 1427 | tok::numeric_constant, tok::l_paren, tok::l_brace, |
| 1428 | tok::kw_true, tok::kw_false)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1429 | return false; |
| 1430 | if (Left.is(tok::coloncolon)) |
| 1431 | return false; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1432 | if (Right.is(tok::coloncolon) && Left.isNot(tok::l_brace)) |
Daniel Jasper | 78a4e61 | 2013-10-12 05:16:06 +0000 | [diff] [blame] | 1433 | return (Left.is(tok::less) && Style.Standard == FormatStyle::LS_Cpp03) || |
| 1434 | !Left.isOneOf(tok::identifier, tok::greater, tok::l_paren, |
| 1435 | tok::r_paren, tok::less); |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 1436 | if (Left.is(tok::less) || Right.isOneOf(tok::greater, tok::less)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1437 | return false; |
Daniel Jasper | c47d7f1 | 2013-07-01 09:47:25 +0000 | [diff] [blame] | 1438 | if (Right.is(tok::ellipsis)) |
Daniel Jasper | b3c887d | 2013-10-20 16:56:16 +0000 | [diff] [blame] | 1439 | return Left.Tok.isLiteral(); |
Manuel Klimek | 31e44f7 | 2013-09-04 08:20:47 +0000 | [diff] [blame] | 1440 | if (Left.is(tok::l_square) && Right.is(tok::amp)) |
| 1441 | return false; |
Alexander Kornienko | 3fd9ccd | 2013-03-12 16:28:18 +0000 | [diff] [blame] | 1442 | if (Right.Type == TT_PointerOrReference) |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1443 | return Left.Tok.isLiteral() || |
Alexander Kornienko | 3fd9ccd | 2013-03-12 16:28:18 +0000 | [diff] [blame] | 1444 | ((Left.Type != TT_PointerOrReference) && Left.isNot(tok::l_paren) && |
| 1445 | !Style.PointerBindsToType); |
Daniel Jasper | 3ff4a2f | 2013-05-28 15:27:10 +0000 | [diff] [blame] | 1446 | if (Right.Type == TT_FunctionTypeLParen && Left.isNot(tok::l_paren) && |
Daniel Jasper | 395228f | 2013-05-08 14:58:20 +0000 | [diff] [blame] | 1447 | (Left.Type != TT_PointerOrReference || Style.PointerBindsToType)) |
| 1448 | return true; |
Alexander Kornienko | 3fd9ccd | 2013-03-12 16:28:18 +0000 | [diff] [blame] | 1449 | if (Left.Type == TT_PointerOrReference) |
Daniel Jasper | 3a1847e | 2013-07-01 09:34:09 +0000 | [diff] [blame] | 1450 | return Right.Tok.isLiteral() || Right.Type == TT_BlockComment || |
Daniel Jasper | 9322aae | 2013-03-20 09:53:18 +0000 | [diff] [blame] | 1451 | ((Right.Type != TT_PointerOrReference) && |
Daniel Jasper | 81d2d38 | 2013-04-01 17:13:26 +0000 | [diff] [blame] | 1452 | Right.isNot(tok::l_paren) && Style.PointerBindsToType && |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1453 | Left.Previous && |
| 1454 | !Left.Previous->isOneOf(tok::l_paren, tok::coloncolon)); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1455 | if (Right.is(tok::star) && Left.is(tok::l_paren)) |
| 1456 | return false; |
Nico Weber | 051860e | 2013-02-10 02:08:05 +0000 | [diff] [blame] | 1457 | if (Left.is(tok::l_square)) |
Daniel Jasper | a07aa66 | 2013-10-22 15:30:28 +0000 | [diff] [blame] | 1458 | return Left.Type == TT_ArrayInitializerLSquare && |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1459 | Style.SpacesInContainerLiterals && Right.isNot(tok::r_square); |
Nico Weber | 051860e | 2013-02-10 02:08:05 +0000 | [diff] [blame] | 1460 | if (Right.is(tok::r_square)) |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1461 | return Right.MatchingParen && Style.SpacesInContainerLiterals && |
Daniel Jasper | a07aa66 | 2013-10-22 15:30:28 +0000 | [diff] [blame] | 1462 | Right.MatchingParen->Type == TT_ArrayInitializerLSquare; |
Daniel Jasper | ec17226 | 2013-08-30 10:36:58 +0000 | [diff] [blame] | 1463 | if (Right.is(tok::l_square) && Right.Type != TT_ObjCMethodExpr && |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1464 | Right.Type != TT_LambdaLSquare && Left.isNot(tok::numeric_constant) && |
| 1465 | Left.Type != TT_DictLiteral) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1466 | return false; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1467 | if (Left.is(tok::colon)) |
| 1468 | return Left.Type != TT_ObjCMethodExpr; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1469 | if (Left.Type == TT_BlockComment) |
| 1470 | return !Left.TokenText.endswith("=*/"); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1471 | if (Right.is(tok::l_paren)) { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1472 | if (Left.is(tok::r_paren) && Left.Type == TT_AttributeParen) |
Daniel Jasper | e0fa4c5 | 2013-07-17 20:25:02 +0000 | [diff] [blame] | 1473 | return true; |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 1474 | return Line.Type == LT_ObjCDecl || |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1475 | Left.isOneOf(tok::kw_new, tok::kw_delete, tok::semi) || |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1476 | (Style.SpaceBeforeParens != FormatStyle::SBPO_Never && |
| 1477 | (Left.isOneOf(tok::kw_if, tok::kw_for, tok::kw_while, |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1478 | tok::kw_switch, tok::kw_catch, tok::kw_case) || |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1479 | Left.IsForEachMacro)) || |
| 1480 | (Style.SpaceBeforeParens == FormatStyle::SBPO_Always && |
| 1481 | Left.isOneOf(tok::identifier, tok::kw___attribute) && |
| 1482 | Line.Type != LT_PreprocessorDirective); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1483 | } |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1484 | if (Left.is(tok::at) && Right.Tok.getObjCKeywordID() != tok::objc_not_keyword) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1485 | return false; |
| 1486 | if (Left.is(tok::l_brace) && Right.is(tok::r_brace)) |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1487 | return !Left.Children.empty(); // No spaces in "{}". |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1488 | if ((Left.is(tok::l_brace) && Left.BlockKind != BK_Block) || |
| 1489 | (Right.is(tok::r_brace) && Right.MatchingParen && |
| 1490 | Right.MatchingParen->BlockKind != BK_Block)) |
Daniel Jasper | b5dc3f4 | 2013-07-16 18:22:10 +0000 | [diff] [blame] | 1491 | return !Style.Cpp11BracedListStyle; |
Daniel Jasper | 1bee073 | 2013-05-23 18:05:18 +0000 | [diff] [blame] | 1492 | if (Right.Type == TT_UnaryOperator) |
| 1493 | return !Left.isOneOf(tok::l_paren, tok::l_square, tok::at) && |
| 1494 | (Left.isNot(tok::colon) || Left.Type != TT_ObjCMethodExpr); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1495 | if ((Left.isOneOf(tok::identifier, tok::greater, tok::r_square) || |
| 1496 | Left.isSimpleTypeSpecifier()) && |
Manuel Klimek | 31e44f7 | 2013-09-04 08:20:47 +0000 | [diff] [blame] | 1497 | Right.is(tok::l_brace) && Right.getNextNonComment() && |
| 1498 | Right.BlockKind != BK_Block) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1499 | return false; |
Daniel Jasper | 5ad390d | 2013-05-28 11:30:49 +0000 | [diff] [blame] | 1500 | if (Left.is(tok::period) || Right.is(tok::period)) |
| 1501 | return false; |
Alexander Kornienko | daa07e9 | 2013-09-10 13:41:43 +0000 | [diff] [blame] | 1502 | if (Right.is(tok::hash) && Left.is(tok::identifier) && Left.TokenText == "L") |
| 1503 | return false; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1504 | return true; |
| 1505 | } |
| 1506 | |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 1507 | bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line, |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1508 | const FormatToken &Tok) { |
| 1509 | if (Tok.Tok.getIdentifierInfo() && Tok.Previous->Tok.getIdentifierInfo()) |
Daniel Jasper | 2b4c924 | 2013-02-11 08:01:18 +0000 | [diff] [blame] | 1510 | return true; // Never ever merge two identifiers. |
Daniel Jasper | 1d82b1a | 2013-10-11 19:45:02 +0000 | [diff] [blame] | 1511 | if (Tok.Previous->Type == TT_ImplicitStringLiteral) |
| 1512 | return Tok.WhitespaceRange.getBegin() != Tok.WhitespaceRange.getEnd(); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1513 | if (Line.Type == LT_ObjCMethodDecl) { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1514 | if (Tok.Previous->Type == TT_ObjCMethodSpecifier) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1515 | return true; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1516 | if (Tok.Previous->is(tok::r_paren) && Tok.is(tok::identifier)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1517 | // Don't space between ')' and <id> |
| 1518 | return false; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1519 | } |
| 1520 | if (Line.Type == LT_ObjCProperty && |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1521 | (Tok.is(tok::equal) || Tok.Previous->is(tok::equal))) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1522 | return false; |
| 1523 | |
Daniel Jasper | 2ca3741 | 2013-07-09 14:36:48 +0000 | [diff] [blame] | 1524 | if (Tok.Type == TT_TrailingReturnArrow || |
| 1525 | Tok.Previous->Type == TT_TrailingReturnArrow) |
| 1526 | return true; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1527 | if (Tok.Previous->is(tok::comma)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1528 | return true; |
Daniel Jasper | 9c3c7b3 | 2013-02-28 13:40:17 +0000 | [diff] [blame] | 1529 | if (Tok.is(tok::comma)) |
| 1530 | return false; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1531 | if (Tok.Type == TT_CtorInitializerColon || Tok.Type == TT_ObjCBlockLParen) |
| 1532 | return true; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1533 | if (Tok.Previous->Tok.is(tok::kw_operator)) |
Daniel Jasper | 52af944 | 2013-10-29 12:24:23 +0000 | [diff] [blame] | 1534 | return Tok.is(tok::coloncolon); |
Daniel Jasper | 2b4c924 | 2013-02-11 08:01:18 +0000 | [diff] [blame] | 1535 | if (Tok.Type == TT_OverloadedOperatorLParen) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1536 | return false; |
| 1537 | if (Tok.is(tok::colon)) |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1538 | return !Line.First->isOneOf(tok::kw_case, tok::kw_default) && |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1539 | Tok.getNextNonComment() && Tok.Type != TT_ObjCMethodExpr && |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1540 | !Tok.Previous->is(tok::question) && |
| 1541 | (Tok.Type != TT_DictLiteral || Style.SpacesInContainerLiterals); |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1542 | if (Tok.Previous->Type == TT_UnaryOperator || |
| 1543 | Tok.Previous->Type == TT_CastRParen) |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1544 | return Tok.Type == TT_BinaryOperator; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1545 | if (Tok.Previous->is(tok::greater) && Tok.is(tok::greater)) { |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 1546 | return Tok.Type == TT_TemplateCloser && |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1547 | Tok.Previous->Type == TT_TemplateCloser && |
Daniel Jasper | d8ee5c1 | 2013-10-29 14:52:02 +0000 | [diff] [blame] | 1548 | (Style.Standard != FormatStyle::LS_Cpp11 || Style.SpacesInAngles); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1549 | } |
Alexander Kornienko | 54a38bd | 2013-03-20 16:41:56 +0000 | [diff] [blame] | 1550 | if (Tok.isOneOf(tok::arrowstar, tok::periodstar) || |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1551 | Tok.Previous->isOneOf(tok::arrowstar, tok::periodstar)) |
Daniel Jasper | 9c3c7b3 | 2013-02-28 13:40:17 +0000 | [diff] [blame] | 1552 | return false; |
Daniel Jasper | 9b4de85 | 2013-09-25 15:15:02 +0000 | [diff] [blame] | 1553 | if (!Style.SpaceBeforeAssignmentOperators && |
| 1554 | Tok.getPrecedence() == prec::Assignment) |
| 1555 | return false; |
Daniel Jasper | 1dc6f74 | 2013-08-07 16:29:23 +0000 | [diff] [blame] | 1556 | if ((Tok.Type == TT_BinaryOperator && !Tok.Previous->is(tok::l_paren)) || |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1557 | Tok.Previous->Type == TT_BinaryOperator || |
| 1558 | Tok.Previous->Type == TT_ConditionalExpr) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1559 | return true; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1560 | if (Tok.Previous->Type == TT_TemplateCloser && Tok.is(tok::l_paren)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1561 | return false; |
Daniel Jasper | a4dd982 | 2013-08-28 08:24:04 +0000 | [diff] [blame] | 1562 | if (Tok.is(tok::less) && Tok.Previous->isNot(tok::l_paren) && |
| 1563 | Line.First->is(tok::hash)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1564 | return true; |
| 1565 | if (Tok.Type == TT_TrailingUnaryOperator) |
| 1566 | return false; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1567 | if (Tok.Previous->Type == TT_RegexLiteral) |
| 1568 | return false; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1569 | return spaceRequiredBetween(Line, *Tok.Previous, Tok); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1570 | } |
| 1571 | |
Daniel Jasper | ebaa171 | 2013-09-17 09:52:48 +0000 | [diff] [blame] | 1572 | bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line, |
| 1573 | const FormatToken &Right) { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1574 | const FormatToken &Left = *Right.Previous; |
Daniel Jasper | ebaa171 | 2013-09-17 09:52:48 +0000 | [diff] [blame] | 1575 | if (Right.is(tok::comment)) { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1576 | return Right.Previous->BlockKind != BK_BracedInit && |
| 1577 | Right.Previous->Type != TT_CtorInitializerColon && |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1578 | (Right.NewlinesBefore > 0 && Right.HasUnescapedNewline); |
Daniel Jasper | ebaa171 | 2013-09-17 09:52:48 +0000 | [diff] [blame] | 1579 | } else if (Right.Previous->isTrailingComment() || |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1580 | (Right.isStringLiteral() && Right.Previous->isStringLiteral())) { |
Daniel Jasper | ebaa171 | 2013-09-17 09:52:48 +0000 | [diff] [blame] | 1581 | return true; |
| 1582 | } else if (Right.Previous->IsUnterminatedLiteral) { |
| 1583 | return true; |
| 1584 | } else if (Right.is(tok::lessless) && Right.Next && |
| 1585 | Right.Previous->is(tok::string_literal) && |
| 1586 | Right.Next->is(tok::string_literal)) { |
| 1587 | return true; |
| 1588 | } else if (Right.Previous->ClosesTemplateDeclaration && |
| 1589 | Right.Previous->MatchingParen && |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1590 | Right.Previous->MatchingParen->NestingLevel == 0 && |
Daniel Jasper | ebaa171 | 2013-09-17 09:52:48 +0000 | [diff] [blame] | 1591 | Style.AlwaysBreakTemplateDeclarations) { |
Daniel Jasper | ebaa171 | 2013-09-17 09:52:48 +0000 | [diff] [blame] | 1592 | return true; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1593 | } else if ((Right.Type == TT_CtorInitializerComma || |
| 1594 | Right.Type == TT_CtorInitializerColon) && |
Daniel Jasper | 19ccb12 | 2013-10-08 05:11:18 +0000 | [diff] [blame] | 1595 | Style.BreakConstructorInitializersBeforeComma && |
| 1596 | !Style.ConstructorInitializerAllOnOneLineOrOnePerLine) { |
Daniel Jasper | ebaa171 | 2013-09-17 09:52:48 +0000 | [diff] [blame] | 1597 | return true; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1598 | } else if (Right.is(tok::l_brace) && Right.BlockKind == BK_Block && |
| 1599 | Right.Type != TT_ObjCBlockLBrace && Right.Type != TT_DictLiteral) { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1600 | return Style.BreakBeforeBraces == FormatStyle::BS_Allman || |
| 1601 | Style.BreakBeforeBraces == FormatStyle::BS_GNU; |
| 1602 | } else if (Right.is(tok::string_literal) && |
| 1603 | Right.TokenText.startswith("R\"")) { |
| 1604 | // Raw string literals are special wrt. line breaks. The author has made a |
| 1605 | // deliberate choice and might have aligned the contents of the string |
| 1606 | // literal accordingly. Thus, we try keep existing line breaks. |
| 1607 | return Right.NewlinesBefore > 0; |
| 1608 | } else if (Right.Previous->is(tok::l_brace) && Right.NestingLevel == 1 && |
| 1609 | Style.Language == FormatStyle::LK_Proto) { |
| 1610 | // Don't enums onto single lines in protocol buffers. |
| 1611 | return true; |
Daniel Jasper | ebaa171 | 2013-09-17 09:52:48 +0000 | [diff] [blame] | 1612 | } |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1613 | |
| 1614 | // If the last token before a '}' is a comma or a comment, the intention is to |
| 1615 | // insert a line break after it in order to make shuffling around entries |
| 1616 | // easier. |
| 1617 | const FormatToken *BeforeClosingBrace = nullptr; |
| 1618 | if (Left.is(tok::l_brace) && Left.MatchingParen) |
| 1619 | BeforeClosingBrace = Left.MatchingParen->Previous; |
| 1620 | else if (Right.is(tok::r_brace)) |
| 1621 | BeforeClosingBrace = Right.Previous; |
| 1622 | if (BeforeClosingBrace && |
| 1623 | BeforeClosingBrace->isOneOf(tok::comma, tok::comment)) |
| 1624 | return true; |
| 1625 | |
| 1626 | if (Style.Language == FormatStyle::LK_JavaScript) { |
| 1627 | // FIXME: This might apply to other languages and token kinds. |
| 1628 | if (Right.is(tok::char_constant) && Left.is(tok::plus) && Left.Previous && |
| 1629 | Left.Previous->is(tok::char_constant)) |
| 1630 | return true; |
| 1631 | } |
| 1632 | |
Daniel Jasper | ebaa171 | 2013-09-17 09:52:48 +0000 | [diff] [blame] | 1633 | return false; |
| 1634 | } |
| 1635 | |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 1636 | bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line, |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1637 | const FormatToken &Right) { |
| 1638 | const FormatToken &Left = *Right.Previous; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1639 | if (Left.is(tok::at)) |
| 1640 | return false; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1641 | if (Left.Tok.getObjCKeywordID() == tok::objc_interface) |
| 1642 | return false; |
Daniel Jasper | 6561f6a | 2013-07-09 07:43:55 +0000 | [diff] [blame] | 1643 | if (Right.Type == TT_StartOfName || Right.is(tok::kw_operator)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1644 | return true; |
Daniel Jasper | 1a896a5 | 2013-11-08 00:57:11 +0000 | [diff] [blame] | 1645 | if (Right.isTrailingComment()) |
| 1646 | // We rely on MustBreakBefore being set correctly here as we should not |
| 1647 | // change the "binding" behavior of a comment. |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1648 | // The first comment in a braced lists is always interpreted as belonging to |
| 1649 | // the first list element. Otherwise, it should be placed outside of the |
| 1650 | // list. |
| 1651 | return Left.BlockKind == BK_BracedInit; |
Daniel Jasper | 1a896a5 | 2013-11-08 00:57:11 +0000 | [diff] [blame] | 1652 | if (Left.is(tok::question) && Right.is(tok::colon)) |
| 1653 | return false; |
| 1654 | if (Right.Type == TT_ConditionalExpr || Right.is(tok::question)) |
| 1655 | return Style.BreakBeforeTernaryOperators; |
| 1656 | if (Left.Type == TT_ConditionalExpr || Left.is(tok::question)) |
| 1657 | return !Style.BreakBeforeTernaryOperators; |
Nico Weber | f2ff812 | 2013-05-26 05:39:26 +0000 | [diff] [blame] | 1658 | if (Right.is(tok::colon) && |
Daniel Jasper | 3c6aea7 | 2013-10-24 10:31:50 +0000 | [diff] [blame] | 1659 | (Right.Type == TT_DictLiteral || Right.Type == TT_ObjCMethodExpr)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1660 | return false; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1661 | if (Right.Type == TT_InheritanceColon) |
| 1662 | return true; |
Nico Weber | f2ff812 | 2013-05-26 05:39:26 +0000 | [diff] [blame] | 1663 | if (Left.is(tok::colon) && |
Daniel Jasper | 3c6aea7 | 2013-10-24 10:31:50 +0000 | [diff] [blame] | 1664 | (Left.Type == TT_DictLiteral || Left.Type == TT_ObjCMethodExpr)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1665 | return true; |
Daniel Jasper | 63d7ced | 2013-02-05 10:07:47 +0000 | [diff] [blame] | 1666 | if (Right.Type == TT_ObjCSelectorName) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1667 | return true; |
Daniel Jasper | aa9e7b1 | 2013-08-01 13:46:58 +0000 | [diff] [blame] | 1668 | if (Left.is(tok::r_paren) && Line.Type == LT_ObjCProperty) |
| 1669 | return true; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1670 | if (Left.ClosesTemplateDeclaration) |
| 1671 | return true; |
Daniel Jasper | 6cabab4 | 2013-02-14 08:42:54 +0000 | [diff] [blame] | 1672 | if (Right.Type == TT_RangeBasedForLoopColon || |
Daniel Jasper | c476ea9 | 2013-08-28 07:27:35 +0000 | [diff] [blame] | 1673 | Right.Type == TT_OverloadedOperatorLParen || |
| 1674 | Right.Type == TT_OverloadedOperator) |
Daniel Jasper | 6cabab4 | 2013-02-14 08:42:54 +0000 | [diff] [blame] | 1675 | return false; |
Daniel Jasper | c194c95 | 2013-05-06 06:45:09 +0000 | [diff] [blame] | 1676 | if (Left.Type == TT_RangeBasedForLoopColon) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1677 | return true; |
Daniel Jasper | 7d81281 | 2013-02-21 15:00:29 +0000 | [diff] [blame] | 1678 | if (Right.Type == TT_RangeBasedForLoopColon) |
| 1679 | return false; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1680 | if (Left.Type == TT_PointerOrReference || Left.Type == TT_TemplateCloser || |
Daniel Jasper | 1a896a5 | 2013-11-08 00:57:11 +0000 | [diff] [blame] | 1681 | Left.Type == TT_UnaryOperator || Left.is(tok::kw_operator)) |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1682 | return false; |
| 1683 | if (Left.is(tok::equal) && Line.Type == LT_VirtualFunctionDecl) |
| 1684 | return false; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1685 | if (Left.is(tok::l_paren) && Left.Type == TT_AttributeParen) |
| 1686 | return false; |
| 1687 | if (Left.is(tok::l_paren) && Left.Previous && |
| 1688 | (Left.Previous->Type == TT_BinaryOperator || |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1689 | Left.Previous->Type == TT_CastRParen || Left.Previous->is(tok::kw_if))) |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1690 | return false; |
Daniel Jasper | 8437957 | 2013-10-30 13:54:53 +0000 | [diff] [blame] | 1691 | if (Right.Type == TT_ImplicitStringLiteral) |
| 1692 | return false; |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1693 | |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1694 | if (Right.is(tok::r_paren) || Right.Type == TT_TemplateCloser) |
| 1695 | return false; |
| 1696 | |
Daniel Jasper | 5ad72bb | 2013-05-22 08:28:26 +0000 | [diff] [blame] | 1697 | // We only break before r_brace if there was a corresponding break before |
| 1698 | // the l_brace, which is tracked by BreakBeforeClosingBrace. |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1699 | if (Right.is(tok::r_brace)) |
| 1700 | return Right.MatchingParen && Right.MatchingParen->BlockKind == BK_Block; |
Daniel Jasper | 5ad72bb | 2013-05-22 08:28:26 +0000 | [diff] [blame] | 1701 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1702 | // Allow breaking after a trailing annotation, e.g. after a method |
| 1703 | // declaration. |
| 1704 | if (Left.Type == TT_TrailingAnnotation) |
| 1705 | return !Right.isOneOf(tok::l_brace, tok::semi, tok::equal, tok::l_paren, |
| 1706 | tok::less, tok::coloncolon); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1707 | |
Daniel Jasper | 8ef19a2 | 2013-03-14 09:50:46 +0000 | [diff] [blame] | 1708 | if (Right.is(tok::kw___attribute)) |
| 1709 | return true; |
| 1710 | |
Daniel Jasper | 3a20441 | 2013-02-23 07:46:38 +0000 | [diff] [blame] | 1711 | if (Left.is(tok::identifier) && Right.is(tok::string_literal)) |
| 1712 | return true; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 1713 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1714 | if (Right.is(tok::identifier) && Right.Next && |
| 1715 | Right.Next->Type == TT_DictLiteral) |
| 1716 | return true; |
| 1717 | |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 1718 | if (Left.Type == TT_CtorInitializerComma && |
| 1719 | Style.BreakConstructorInitializersBeforeComma) |
| 1720 | return false; |
Daniel Jasper | 19ccb12 | 2013-10-08 05:11:18 +0000 | [diff] [blame] | 1721 | if (Right.Type == TT_CtorInitializerComma && |
| 1722 | Style.BreakConstructorInitializersBeforeComma) |
| 1723 | return true; |
Daniel Jasper | 26356cc | 2013-09-17 08:15:46 +0000 | [diff] [blame] | 1724 | if (Left.is(tok::greater) && Right.is(tok::greater) && |
| 1725 | Left.Type != TT_TemplateCloser) |
| 1726 | return false; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1727 | if (Right.Type == TT_BinaryOperator && Style.BreakBeforeBinaryOperators) |
| 1728 | return true; |
Daniel Jasper | a07aa66 | 2013-10-22 15:30:28 +0000 | [diff] [blame] | 1729 | if (Left.Type == TT_ArrayInitializerLSquare) |
| 1730 | return true; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 1731 | return (Left.isBinaryOperator() && Left.isNot(tok::lessless) && |
| 1732 | !Style.BreakBeforeBinaryOperators) || |
Daniel Jasper | 6b119d6 | 2013-04-05 17:22:09 +0000 | [diff] [blame] | 1733 | Left.isOneOf(tok::comma, tok::coloncolon, tok::semi, tok::l_brace, |
| 1734 | tok::kw_class, tok::kw_struct) || |
Daniel Jasper | a07aa66 | 2013-10-22 15:30:28 +0000 | [diff] [blame] | 1735 | Right.isOneOf(tok::lessless, tok::arrow, tok::period, tok::colon, |
| 1736 | tok::l_square, tok::at) || |
Daniel Jasper | 198c8bf | 2013-07-05 07:58:34 +0000 | [diff] [blame] | 1737 | (Left.is(tok::r_paren) && |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1738 | Right.isOneOf(tok::identifier, tok::kw_const)) || |
Daniel Jasper | a07aa66 | 2013-10-22 15:30:28 +0000 | [diff] [blame] | 1739 | (Left.is(tok::l_paren) && !Right.is(tok::r_paren)); |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1740 | } |
| 1741 | |
Daniel Jasper | bf71ba2 | 2013-04-08 20:33:42 +0000 | [diff] [blame] | 1742 | void TokenAnnotator::printDebugInfo(const AnnotatedLine &Line) { |
| 1743 | llvm::errs() << "AnnotatedTokens:\n"; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1744 | const FormatToken *Tok = Line.First; |
Daniel Jasper | bf71ba2 | 2013-04-08 20:33:42 +0000 | [diff] [blame] | 1745 | while (Tok) { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1746 | llvm::errs() << " M=" << Tok->MustBreakBefore |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 1747 | << " C=" << Tok->CanBreakBefore << " T=" << Tok->Type |
| 1748 | << " S=" << Tok->SpacesRequiredBefore |
| 1749 | << " P=" << Tok->SplitPenalty << " Name=" << Tok->Tok.getName() |
Manuel Klimek | ae76f7f | 2013-10-11 21:25:45 +0000 | [diff] [blame] | 1750 | << " L=" << Tok->TotalLength << " PPK=" << Tok->PackingKind |
| 1751 | << " FakeLParens="; |
Daniel Jasper | bf71ba2 | 2013-04-08 20:33:42 +0000 | [diff] [blame] | 1752 | for (unsigned i = 0, e = Tok->FakeLParens.size(); i != e; ++i) |
| 1753 | llvm::errs() << Tok->FakeLParens[i] << "/"; |
| 1754 | llvm::errs() << " FakeRParens=" << Tok->FakeRParens << "\n"; |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1755 | if (!Tok->Next) |
Manuel Klimek | ae76f7f | 2013-10-11 21:25:45 +0000 | [diff] [blame] | 1756 | assert(Tok == Line.Last); |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1757 | Tok = Tok->Next; |
Daniel Jasper | bf71ba2 | 2013-04-08 20:33:42 +0000 | [diff] [blame] | 1758 | } |
| 1759 | llvm::errs() << "----\n"; |
| 1760 | } |
| 1761 | |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 1762 | } // namespace format |
| 1763 | } // namespace clang |