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___bf16:
54  case tok::kw__Float16:
55  case tok::kw___float128:
56  case tok::kw___ibm128:
57  case tok::kw_wchar_t:
58  case tok::kw_bool:
59#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
60#include "clang/Basic/TransformTypeTraits.def"
61  case tok::annot_typename:
62  case tok::kw_char8_t:
63  case tok::kw_char16_t:
64  case tok::kw_char32_t:
65  case tok::kw_typeof:
66  case tok::kw_decltype:
67  case tok::kw__Atomic:
68    return true;
69  default:
70    return false;
71  }
72}
73
74bool FormatToken::isTypeOrIdentifier() const {
75  return isSimpleTypeSpecifier() || Tok.isOneOf(tok::kw_auto, tok::identifier);
76}
77
78bool FormatToken::opensBlockOrBlockTypeList(const FormatStyle &Style) const {
79  // C# Does not indent object initialisers as continuations.
80  if (is(tok::l_brace) && getBlockKind() == BK_BracedInit && Style.isCSharp())
81    return true;
82  if (is(TT_TemplateString) && opensScope())
83    return true;
84  return is(TT_ArrayInitializerLSquare) || is(TT_ProtoExtensionLSquare) ||
85         (is(tok::l_brace) &&
86          (getBlockKind() == BK_Block || is(TT_DictLiteral) ||
87           (!Style.Cpp11BracedListStyle && NestingLevel == 0))) ||
88         (is(tok::less) && (Style.Language == FormatStyle::LK_Proto ||
89                            Style.Language == FormatStyle::LK_TextProto));
90}
91
92TokenRole::~TokenRole() {}
93
94void TokenRole::precomputeFormattingInfos(const FormatToken *Token) {}
95
96unsigned CommaSeparatedList::formatAfterToken(LineState &State,
97                                              ContinuationIndenter *Indenter,
98                                              bool DryRun) {
99  if (State.NextToken == nullptr || !State.NextToken->Previous)
100    return 0;
101
102  if (Formats.size() == 1)
103    return 0; // Handled by formatFromToken
104
105  // Ensure that we start on the opening brace.
106  const FormatToken *LBrace =
107      State.NextToken->Previous->getPreviousNonComment();
108  if (!LBrace || !LBrace->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
109      LBrace->is(BK_Block) || LBrace->is(TT_DictLiteral) ||
110      LBrace->Next->is(TT_DesignatedInitializerPeriod)) {
111    return 0;
112  }
113
114  // Calculate the number of code points we have to format this list. As the
115  // first token is already placed, we have to subtract it.
116  unsigned RemainingCodePoints =
117      Style.ColumnLimit - State.Column + State.NextToken->Previous->ColumnWidth;
118
119  // Find the best ColumnFormat, i.e. the best number of columns to use.
120  const ColumnFormat *Format = getColumnFormat(RemainingCodePoints);
121
122  // If no ColumnFormat can be used, the braced list would generally be
123  // bin-packed. Add a severe penalty to this so that column layouts are
124  // preferred if possible.
125  if (!Format)
126    return 10000;
127
128  // Format the entire list.
129  unsigned Penalty = 0;
130  unsigned Column = 0;
131  unsigned Item = 0;
132  while (State.NextToken != LBrace->MatchingParen) {
133    bool NewLine = false;
134    unsigned ExtraSpaces = 0;
135
136    // If the previous token was one of our commas, we are now on the next item.
137    if (Item < Commas.size() && State.NextToken->Previous == Commas[Item]) {
138      if (!State.NextToken->isTrailingComment()) {
139        ExtraSpaces += Format->ColumnSizes[Column] - ItemLengths[Item];
140        ++Column;
141      }
142      ++Item;
143    }
144
145    if (Column == Format->Columns || State.NextToken->MustBreakBefore) {
146      Column = 0;
147      NewLine = true;
148    }
149
150    // Place token using the continuation indenter and store the penalty.
151    Penalty += Indenter->addTokenToState(State, NewLine, DryRun, ExtraSpaces);
152  }
153  return Penalty;
154}
155
156unsigned CommaSeparatedList::formatFromToken(LineState &State,
157                                             ContinuationIndenter *Indenter,
158                                             bool DryRun) {
159  // Formatting with 1 Column isn't really a column layout, so we don't need the
160  // special logic here. We can just avoid bin packing any of the parameters.
161  if (Formats.size() == 1 || HasNestedBracedList)
162    State.Stack.back().AvoidBinPacking = true;
163  return 0;
164}
165
166// Returns the lengths in code points between Begin and End (both included),
167// assuming that the entire sequence is put on a single line.
168static unsigned CodePointsBetween(const FormatToken *Begin,
169                                  const FormatToken *End) {
170  assert(End->TotalLength >= Begin->TotalLength);
171  return End->TotalLength - Begin->TotalLength + Begin->ColumnWidth;
172}
173
174void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) {
175  // FIXME: At some point we might want to do this for other lists, too.
176  if (!Token->MatchingParen ||
177      !Token->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare)) {
178    return;
179  }
180
181  // In C++11 braced list style, we should not format in columns unless they
182  // have many items (20 or more) or we allow bin-packing of function call
183  // arguments.
184  if (Style.Cpp11BracedListStyle && !Style.BinPackArguments &&
185      Commas.size() < 19) {
186    return;
187  }
188
189  // Limit column layout for JavaScript array initializers to 20 or more items
190  // for now to introduce it carefully. We can become more aggressive if this
191  // necessary.
192  if (Token->is(TT_ArrayInitializerLSquare) && Commas.size() < 19)
193    return;
194
195  // Column format doesn't really make sense if we don't align after brackets.
196  if (Style.AlignAfterOpenBracket == FormatStyle::BAS_DontAlign)
197    return;
198
199  FormatToken *ItemBegin = Token->Next;
200  while (ItemBegin->isTrailingComment())
201    ItemBegin = ItemBegin->Next;
202  SmallVector<bool, 8> MustBreakBeforeItem;
203
204  // The lengths of an item if it is put at the end of the line. This includes
205  // trailing comments which are otherwise ignored for column alignment.
206  SmallVector<unsigned, 8> EndOfLineItemLength;
207  MustBreakBeforeItem.reserve(Commas.size() + 1);
208  EndOfLineItemLength.reserve(Commas.size() + 1);
209  ItemLengths.reserve(Commas.size() + 1);
210
211  bool HasSeparatingComment = false;
212  for (unsigned i = 0, e = Commas.size() + 1; i != e; ++i) {
213    assert(ItemBegin);
214    // Skip comments on their own line.
215    while (ItemBegin->HasUnescapedNewline && ItemBegin->isTrailingComment()) {
216      ItemBegin = ItemBegin->Next;
217      HasSeparatingComment = i > 0;
218    }
219
220    MustBreakBeforeItem.push_back(ItemBegin->MustBreakBefore);
221    if (ItemBegin->is(tok::l_brace))
222      HasNestedBracedList = true;
223    const FormatToken *ItemEnd = nullptr;
224    if (i == Commas.size()) {
225      ItemEnd = Token->MatchingParen;
226      const FormatToken *NonCommentEnd = ItemEnd->getPreviousNonComment();
227      ItemLengths.push_back(CodePointsBetween(ItemBegin, NonCommentEnd));
228      if (Style.Cpp11BracedListStyle &&
229          !ItemEnd->Previous->isTrailingComment()) {
230        // In Cpp11 braced list style, the } and possibly other subsequent
231        // tokens will need to stay on a line with the last element.
232        while (ItemEnd->Next && !ItemEnd->Next->CanBreakBefore)
233          ItemEnd = ItemEnd->Next;
234      } else {
235        // In other braced lists styles, the "}" can be wrapped to the new line.
236        ItemEnd = Token->MatchingParen->Previous;
237      }
238    } else {
239      ItemEnd = Commas[i];
240      // The comma is counted as part of the item when calculating the length.
241      ItemLengths.push_back(CodePointsBetween(ItemBegin, ItemEnd));
242
243      // Consume trailing comments so the are included in EndOfLineItemLength.
244      if (ItemEnd->Next && !ItemEnd->Next->HasUnescapedNewline &&
245          ItemEnd->Next->isTrailingComment()) {
246        ItemEnd = ItemEnd->Next;
247      }
248    }
249    EndOfLineItemLength.push_back(CodePointsBetween(ItemBegin, ItemEnd));
250    // If there is a trailing comma in the list, the next item will start at the
251    // closing brace. Don't create an extra item for this.
252    if (ItemEnd->getNextNonComment() == Token->MatchingParen)
253      break;
254    ItemBegin = ItemEnd->Next;
255  }
256
257  // Don't use column layout for lists with few elements and in presence of
258  // separating comments.
259  if (Commas.size() < 5 || HasSeparatingComment)
260    return;
261
262  if (Token->NestingLevel != 0 && Token->is(tok::l_brace) && Commas.size() < 19)
263    return;
264
265  // We can never place more than ColumnLimit / 3 items in a row (because of the
266  // spaces and the comma).
267  unsigned MaxItems = Style.ColumnLimit / 3;
268  SmallVector<unsigned> MinSizeInColumn;
269  MinSizeInColumn.reserve(MaxItems);
270  for (unsigned Columns = 1; Columns <= MaxItems; ++Columns) {
271    ColumnFormat Format;
272    Format.Columns = Columns;
273    Format.ColumnSizes.resize(Columns);
274    MinSizeInColumn.assign(Columns, UINT_MAX);
275    Format.LineCount = 1;
276    bool HasRowWithSufficientColumns = false;
277    unsigned Column = 0;
278    for (unsigned i = 0, e = ItemLengths.size(); i != e; ++i) {
279      assert(i < MustBreakBeforeItem.size());
280      if (MustBreakBeforeItem[i] || Column == Columns) {
281        ++Format.LineCount;
282        Column = 0;
283      }
284      if (Column == Columns - 1)
285        HasRowWithSufficientColumns = true;
286      unsigned Length =
287          (Column == Columns - 1) ? EndOfLineItemLength[i] : ItemLengths[i];
288      Format.ColumnSizes[Column] = std::max(Format.ColumnSizes[Column], Length);
289      MinSizeInColumn[Column] = std::min(MinSizeInColumn[Column], Length);
290      ++Column;
291    }
292    // If all rows are terminated early (e.g. by trailing comments), we don't
293    // need to look further.
294    if (!HasRowWithSufficientColumns)
295      break;
296    Format.TotalWidth = Columns - 1; // Width of the N-1 spaces.
297
298    for (unsigned i = 0; i < Columns; ++i)
299      Format.TotalWidth += Format.ColumnSizes[i];
300
301    // Don't use this Format, if the difference between the longest and shortest
302    // element in a column exceeds a threshold to avoid excessive spaces.
303    if ([&] {
304          for (unsigned i = 0; i < Columns - 1; ++i)
305            if (Format.ColumnSizes[i] - MinSizeInColumn[i] > 10)
306              return true;
307          return false;
308        }()) {
309      continue;
310    }
311
312    // Ignore layouts that are bound to violate the column limit.
313    if (Format.TotalWidth > Style.ColumnLimit && Columns > 1)
314      continue;
315
316    Formats.push_back(Format);
317  }
318}
319
320const CommaSeparatedList::ColumnFormat *
321CommaSeparatedList::getColumnFormat(unsigned RemainingCharacters) const {
322  const ColumnFormat *BestFormat = nullptr;
323  for (const ColumnFormat &Format : llvm::reverse(Formats)) {
324    if (Format.TotalWidth <= RemainingCharacters || Format.Columns == 1) {
325      if (BestFormat && Format.LineCount > BestFormat->LineCount)
326        break;
327      BestFormat = &Format;
328    }
329  }
330  return BestFormat;
331}
332
333} // namespace format
334} // namespace clang
335