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