FormatToken.cpp revision 360660 
1//===--- FormatToken.cpp - Format C++ code --------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// This file implements specific functions of \c FormatTokens and their
11/// roles.
12///
13//===----------------------------------------------------------------------===//
14
15#include "FormatToken.h"
16#include "ContinuationIndenter.h"
17#include "llvm/ADT/SmallVector.h"
18#include "llvm/Support/Debug.h"
19#include <climits>
20
21namespace clang {
22namespace format {
23
24const char *getTokenTypeName(TokenType Type) {
25  static const char *const TokNames[] = {
26#define TYPE(X) #X,
27      LIST_TOKEN_TYPES
28#undef TYPE
29      nullptr};
30
31  if (Type < NUM_TOKEN_TYPES)
32    return TokNames[Type];
33  llvm_unreachable("unknown TokenType");
34  return nullptr;
35}
36
37// FIXME: This is copy&pasted from Sema. Put it in a common place and remove
38// duplication.
39bool FormatToken::isSimpleTypeSpecifier() const {
40  switch (Tok.getKind()) {
41  case tok::kw_short:
42  case tok::kw_long:
43  case tok::kw___int64:
44  case tok::kw___int128:
45  case tok::kw_signed:
46  case tok::kw_unsigned:
47  case tok::kw_void:
48  case tok::kw_char:
49  case tok::kw_int:
50  case tok::kw_half:
51  case tok::kw_float:
52  case tok::kw_double:
53  case tok::kw__Float16:
54  case tok::kw___float128:
55  case tok::kw_wchar_t:
56  case tok::kw_bool:
57  case tok::kw___underlying_type:
58  case tok::annot_typename:
59  case tok::kw_char8_t:
60  case tok::kw_char16_t:
61  case tok::kw_char32_t:
62  case tok::kw_typeof:
63  case tok::kw_decltype:
64    return true;
65  default:
66    return false;
67  }
68}
69
70TokenRole::~TokenRole() {}
71
72void TokenRole::precomputeFormattingInfos(const FormatToken *Token) {}
73
74unsigned CommaSeparatedList::formatAfterToken(LineState &State,
75                                              ContinuationIndenter *Indenter,
76                                              bool DryRun) {
77  if (State.NextToken == nullptr || !State.NextToken->Previous)
78    return 0;
79
80  if (Formats.size() == 1)
81    return 0; // Handled by formatFromToken
82
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)
89    return 0;
90
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;
95
96  // Find the best ColumnFormat, i.e. the best number of columns to use.
97  const ColumnFormat *Format = getColumnFormat(RemainingCodePoints);
98
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.
102  if (!Format)
103    return 10000;
104
105  // Format the entire list.
106  unsigned Penalty = 0;
107  unsigned Column = 0;
108  unsigned Item = 0;
109  while (State.NextToken != LBrace->MatchingParen) {
110    bool NewLine = false;
111    unsigned ExtraSpaces = 0;
112
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];
117        ++Column;
118      }
119      ++Item;
120    }
121
122    if (Column == Format->Columns || State.NextToken->MustBreakBefore) {
123      Column = 0;
124      NewLine = true;
125    }
126
127    // Place token using the continuation indenter and store the penalty.
128    Penalty += Indenter->addTokenToState(State, NewLine, DryRun, ExtraSpaces);
129  }
130  return Penalty;
131}
132
133unsigned CommaSeparatedList::formatFromToken(LineState &State,
134                                             ContinuationIndenter *Indenter,
135                                             bool DryRun) {
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;
140  return 0;
141}
142
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.
145static unsigned CodePointsBetween(const FormatToken *Begin,
146                                  const FormatToken *End) {
147  assert(End->TotalLength >= Begin->TotalLength);
148  return End->TotalLength - Begin->TotalLength + Begin->ColumnWidth;
149}
150
151void 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))
155    return;
156
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
159  // arguments.
160  if (Style.Cpp11BracedListStyle && !Style.BinPackArguments &&
161      Commas.size() < 19)
162    return;
163
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
166  // necessary.
167  if (Token->is(TT_ArrayInitializerLSquare) && Commas.size() < 19)
168    return;
169
170  // Column format doesn't really make sense if we don't align after brackets.
171  if (Style.AlignAfterOpenBracket == FormatStyle::BAS_DontAlign)
172    return;
173
174  FormatToken *ItemBegin = Token->Next;
175  while (ItemBegin->isTrailingComment())
176    ItemBegin = ItemBegin->Next;
177  SmallVector<bool, 8> MustBreakBeforeItem;
178
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;
182
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;
189    }
190
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;
205      } else {
206        // In other braced lists styles, the "}" can be wrapped to the new line.
207        ItemEnd = Token->MatchingParen->Previous;
208      }
209    } else {
210      ItemEnd = Commas[i];
211      // The comma is counted as part of the item when calculating the length.
212      ItemLengths.push_back(CodePointsBetween(ItemBegin, ItemEnd));
213
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;
218    }
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)
223      break;
224    ItemBegin = ItemEnd->Next;
225  }
226
227  // Don't use column layout for lists with few elements and in presence of
228  // separating comments.
229  if (Commas.size() < 5 || HasSeparatingComment)
230    return;
231
232  if (Token->NestingLevel != 0 && Token->is(tok::l_brace) && Commas.size() < 19)
233    return;
234
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) {
241    ColumnFormat Format;
242    Format.Columns = Columns;
243    Format.ColumnSizes.resize(Columns);
244    MinSizeInColumn.assign(Columns, UINT_MAX);
245    Format.LineCount = 1;
246    bool HasRowWithSufficientColumns = false;
247    unsigned Column = 0;
248    for (unsigned i = 0, e = ItemLengths.size(); i != e; ++i) {
249      assert(i < MustBreakBeforeItem.size());
250      if (MustBreakBeforeItem[i] || Column == Columns) {
251        ++Format.LineCount;
252        Column = 0;
253      }
254      if (Column == Columns - 1)
255        HasRowWithSufficientColumns = true;
256      unsigned Length =
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);
260      ++Column;
261    }
262    // If all rows are terminated early (e.g. by trailing comments), we don't
263    // need to look further.
264    if (!HasRowWithSufficientColumns)
265      break;
266    Format.TotalWidth = Columns - 1; // Width of the N-1 spaces.
267
268    for (unsigned i = 0; i < Columns; ++i)
269      Format.TotalWidth += Format.ColumnSizes[i];
270
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.
273    if ([&] {
274          for (unsigned i = 0; i < Columns - 1; ++i)
275            if (Format.ColumnSizes[i] - MinSizeInColumn[i] > 10)
276              return true;
277          return false;
278        }())
279      continue;
280
281    // Ignore layouts that are bound to violate the column limit.
282    if (Format.TotalWidth > Style.ColumnLimit && Columns > 1)
283      continue;
284
285    Formats.push_back(Format);
286  }
287}
288
289const CommaSeparatedList::ColumnFormat *
290CommaSeparatedList::getColumnFormat(unsigned RemainingCharacters) const {
291  const ColumnFormat *BestFormat = nullptr;
292  for (SmallVector<ColumnFormat, 4>::const_reverse_iterator
293           I = Formats.rbegin(),
294           E = Formats.rend();
295       I != E; ++I) {
296    if (I->TotalWidth <= RemainingCharacters || I->Columns == 1) {
297      if (BestFormat && I->LineCount > BestFormat->LineCount)
298        break;
299      BestFormat = &*I;
300    }
301  }
302  return BestFormat;
303}
304
305} // namespace format
306} // namespace clang
307