1 //===--- FormatToken.cpp - Format C++ code --------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// \brief This file implements specific functions of \c FormatTokens and their
14 //===----------------------------------------------------------------------===//
16 #include "FormatToken.h"
17 #include "ContinuationIndenter.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/Support/Debug.h"
25 const char *getTokenTypeName(TokenType Type) {
26 static const char *const TokNames[] = {
32 if (Type < NUM_TOKEN_TYPES)
33 return TokNames[Type];
34 llvm_unreachable("unknown TokenType");
38 // FIXME: This is copy&pasted from Sema. Put it in a common place and remove
40 bool FormatToken::isSimpleTypeSpecifier() const {
41 switch (Tok.getKind()) {
45 case tok::kw___int128:
47 case tok::kw_unsigned:
54 case tok::kw__Float16:
55 case tok::kw___float128:
58 case tok::kw___underlying_type:
59 case tok::annot_typename:
60 case tok::kw_char16_t:
61 case tok::kw_char32_t:
63 case tok::kw_decltype:
70 TokenRole::~TokenRole() {}
72 void TokenRole::precomputeFormattingInfos(const FormatToken *Token) {}
74 unsigned CommaSeparatedList::formatAfterToken(LineState &State,
75 ContinuationIndenter *Indenter,
77 if (State.NextToken == nullptr || !State.NextToken->Previous)
80 if (Formats.size() == 1)
81 return 0; // Handled by formatFromToken
83 // Ensure that we start on the opening brace.
84 const FormatToken *LBrace =
85 State.NextToken->Previous->getPreviousNonComment();
86 if (!LBrace || !LBrace->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
87 LBrace->BlockKind == BK_Block || LBrace->Type == TT_DictLiteral ||
88 LBrace->Next->Type == TT_DesignatedInitializerPeriod)
91 // Calculate the number of code points we have to format this list. As the
92 // first token is already placed, we have to subtract it.
93 unsigned RemainingCodePoints =
94 Style.ColumnLimit - State.Column + State.NextToken->Previous->ColumnWidth;
96 // Find the best ColumnFormat, i.e. the best number of columns to use.
97 const ColumnFormat *Format = getColumnFormat(RemainingCodePoints);
99 // If no ColumnFormat can be used, the braced list would generally be
100 // bin-packed. Add a severe penalty to this so that column layouts are
101 // preferred if possible.
105 // Format the entire list.
106 unsigned Penalty = 0;
109 while (State.NextToken != LBrace->MatchingParen) {
110 bool NewLine = false;
111 unsigned ExtraSpaces = 0;
113 // If the previous token was one of our commas, we are now on the next item.
114 if (Item < Commas.size() && State.NextToken->Previous == Commas[Item]) {
115 if (!State.NextToken->isTrailingComment()) {
116 ExtraSpaces += Format->ColumnSizes[Column] - ItemLengths[Item];
122 if (Column == Format->Columns || State.NextToken->MustBreakBefore) {
127 // Place token using the continuation indenter and store the penalty.
128 Penalty += Indenter->addTokenToState(State, NewLine, DryRun, ExtraSpaces);
133 unsigned CommaSeparatedList::formatFromToken(LineState &State,
134 ContinuationIndenter *Indenter,
136 // Formatting with 1 Column isn't really a column layout, so we don't need the
137 // special logic here. We can just avoid bin packing any of the parameters.
138 if (Formats.size() == 1 || HasNestedBracedList)
139 State.Stack.back().AvoidBinPacking = true;
143 // Returns the lengths in code points between Begin and End (both included),
144 // assuming that the entire sequence is put on a single line.
145 static unsigned CodePointsBetween(const FormatToken *Begin,
146 const FormatToken *End) {
147 assert(End->TotalLength >= Begin->TotalLength);
148 return End->TotalLength - Begin->TotalLength + Begin->ColumnWidth;
151 void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) {
152 // FIXME: At some point we might want to do this for other lists, too.
153 if (!Token->MatchingParen ||
154 !Token->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare))
157 // In C++11 braced list style, we should not format in columns unless they
158 // have many items (20 or more) or we allow bin-packing of function call
160 if (Style.Cpp11BracedListStyle && !Style.BinPackArguments &&
164 // Limit column layout for JavaScript array initializers to 20 or more items
165 // for now to introduce it carefully. We can become more aggressive if this
167 if (Token->is(TT_ArrayInitializerLSquare) && Commas.size() < 19)
170 // Column format doesn't really make sense if we don't align after brackets.
171 if (Style.AlignAfterOpenBracket == FormatStyle::BAS_DontAlign)
174 FormatToken *ItemBegin = Token->Next;
175 while (ItemBegin->isTrailingComment())
176 ItemBegin = ItemBegin->Next;
177 SmallVector<bool, 8> MustBreakBeforeItem;
179 // The lengths of an item if it is put at the end of the line. This includes
180 // trailing comments which are otherwise ignored for column alignment.
181 SmallVector<unsigned, 8> EndOfLineItemLength;
183 bool HasSeparatingComment = false;
184 for (unsigned i = 0, e = Commas.size() + 1; i != e; ++i) {
185 // Skip comments on their own line.
186 while (ItemBegin->HasUnescapedNewline && ItemBegin->isTrailingComment()) {
187 ItemBegin = ItemBegin->Next;
188 HasSeparatingComment = i > 0;
191 MustBreakBeforeItem.push_back(ItemBegin->MustBreakBefore);
192 if (ItemBegin->is(tok::l_brace))
193 HasNestedBracedList = true;
194 const FormatToken *ItemEnd = nullptr;
195 if (i == Commas.size()) {
196 ItemEnd = Token->MatchingParen;
197 const FormatToken *NonCommentEnd = ItemEnd->getPreviousNonComment();
198 ItemLengths.push_back(CodePointsBetween(ItemBegin, NonCommentEnd));
199 if (Style.Cpp11BracedListStyle &&
200 !ItemEnd->Previous->isTrailingComment()) {
201 // In Cpp11 braced list style, the } and possibly other subsequent
202 // tokens will need to stay on a line with the last element.
203 while (ItemEnd->Next && !ItemEnd->Next->CanBreakBefore)
204 ItemEnd = ItemEnd->Next;
206 // In other braced lists styles, the "}" can be wrapped to the new line.
207 ItemEnd = Token->MatchingParen->Previous;
211 // The comma is counted as part of the item when calculating the length.
212 ItemLengths.push_back(CodePointsBetween(ItemBegin, ItemEnd));
214 // Consume trailing comments so the are included in EndOfLineItemLength.
215 if (ItemEnd->Next && !ItemEnd->Next->HasUnescapedNewline &&
216 ItemEnd->Next->isTrailingComment())
217 ItemEnd = ItemEnd->Next;
219 EndOfLineItemLength.push_back(CodePointsBetween(ItemBegin, ItemEnd));
220 // If there is a trailing comma in the list, the next item will start at the
221 // closing brace. Don't create an extra item for this.
222 if (ItemEnd->getNextNonComment() == Token->MatchingParen)
224 ItemBegin = ItemEnd->Next;
227 // Don't use column layout for lists with few elements and in presence of
228 // separating comments.
229 if (Commas.size() < 5 || HasSeparatingComment)
232 if (Token->NestingLevel != 0 && Token->is(tok::l_brace) && Commas.size() < 19)
235 // We can never place more than ColumnLimit / 3 items in a row (because of the
236 // spaces and the comma).
237 unsigned MaxItems = Style.ColumnLimit / 3;
238 std::vector<unsigned> MinSizeInColumn;
239 MinSizeInColumn.reserve(MaxItems);
240 for (unsigned Columns = 1; Columns <= MaxItems; ++Columns) {
242 Format.Columns = Columns;
243 Format.ColumnSizes.resize(Columns);
244 MinSizeInColumn.assign(Columns, UINT_MAX);
245 Format.LineCount = 1;
246 bool HasRowWithSufficientColumns = false;
248 for (unsigned i = 0, e = ItemLengths.size(); i != e; ++i) {
249 assert(i < MustBreakBeforeItem.size());
250 if (MustBreakBeforeItem[i] || Column == Columns) {
254 if (Column == Columns - 1)
255 HasRowWithSufficientColumns = true;
257 (Column == Columns - 1) ? EndOfLineItemLength[i] : ItemLengths[i];
258 Format.ColumnSizes[Column] = std::max(Format.ColumnSizes[Column], Length);
259 MinSizeInColumn[Column] = std::min(MinSizeInColumn[Column], Length);
262 // If all rows are terminated early (e.g. by trailing comments), we don't
263 // need to look further.
264 if (!HasRowWithSufficientColumns)
266 Format.TotalWidth = Columns - 1; // Width of the N-1 spaces.
268 for (unsigned i = 0; i < Columns; ++i)
269 Format.TotalWidth += Format.ColumnSizes[i];
271 // Don't use this Format, if the difference between the longest and shortest
272 // element in a column exceeds a threshold to avoid excessive spaces.
274 for (unsigned i = 0; i < Columns - 1; ++i)
275 if (Format.ColumnSizes[i] - MinSizeInColumn[i] > 10)
281 // Ignore layouts that are bound to violate the column limit.
282 if (Format.TotalWidth > Style.ColumnLimit && Columns > 1)
285 Formats.push_back(Format);
289 const CommaSeparatedList::ColumnFormat *
290 CommaSeparatedList::getColumnFormat(unsigned RemainingCharacters) const {
291 const ColumnFormat *BestFormat = nullptr;
292 for (SmallVector<ColumnFormat, 4>::const_reverse_iterator
293 I = Formats.rbegin(),
296 if (I->TotalWidth <= RemainingCharacters || I->Columns == 1) {
297 if (BestFormat && I->LineCount > BestFormat->LineCount)
305 } // namespace format