Home | History | Annotate | Download | only in Format 
      1 //===--- FormatToken.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 specific functions of \c FormatTokens and their
     12 /// roles.
     13 ///
     14 //===----------------------------------------------------------------------===//
     15 
     16 #include "FormatToken.h"
     17 #include "ContinuationIndenter.h"
     18 #include "clang/Format/Format.h"
     19 #include "llvm/ADT/SmallVector.h"
     20 #include "llvm/Support/Debug.h"
     21 
     22 namespace clang {
     23 namespace format {
     24 
     25 // FIXME: This is copy&pasted from Sema. Put it in a common place and remove
     26 // duplication.
     27 bool FormatToken::isSimpleTypeSpecifier() const {
     28   switch (Tok.getKind()) {
     29   case tok::kw_short:
     30   case tok::kw_long:
     31   case tok::kw___int64:
     32   case tok::kw___int128:
     33   case tok::kw_signed:
     34   case tok::kw_unsigned:
     35   case tok::kw_void:
     36   case tok::kw_char:
     37   case tok::kw_int:
     38   case tok::kw_half:
     39   case tok::kw_float:
     40   case tok::kw_double:
     41   case tok::kw_wchar_t:
     42   case tok::kw_bool:
     43   case tok::kw___underlying_type:
     44   case tok::annot_typename:
     45   case tok::kw_char16_t:
     46   case tok::kw_char32_t:
     47   case tok::kw_typeof:
     48   case tok::kw_decltype:
     49     return true;
     50   default:
     51     return false;
     52   }
     53 }
     54 
     55 TokenRole::~TokenRole() {}
     56 
     57 void TokenRole::precomputeFormattingInfos(const FormatToken *Token) {}
     58 
     59 unsigned CommaSeparatedList::formatAfterToken(LineState &State,
     60                                               ContinuationIndenter *Indenter,
     61                                               bool DryRun) {
     62   if (State.NextToken == nullptr || !State.NextToken->Previous ||
     63       !State.NextToken->Previous->Previous)
     64     return 0;
     65 
     66   // Ensure that we start on the opening brace.
     67   const FormatToken *LBrace = State.NextToken->Previous->Previous;
     68   if (LBrace->isNot(tok::l_brace) || LBrace->BlockKind == BK_Block ||
     69       LBrace->Type == TT_DictLiteral ||
     70       LBrace->Next->Type == TT_DesignatedInitializerPeriod)
     71     return 0;
     72 
     73   // Calculate the number of code points we have to format this list. As the
     74   // first token is already placed, we have to subtract it.
     75   unsigned RemainingCodePoints =
     76       Style.ColumnLimit - State.Column + State.NextToken->Previous->ColumnWidth;
     77 
     78   // Find the best ColumnFormat, i.e. the best number of columns to use.
     79   const ColumnFormat *Format = getColumnFormat(RemainingCodePoints);
     80   // If no ColumnFormat can be used, the braced list would generally be
     81   // bin-packed. Add a severe penalty to this so that column layouts are
     82   // preferred if possible.
     83   if (!Format)
     84     return 10000;
     85 
     86   // Format the entire list.
     87   unsigned Penalty = 0;
     88   unsigned Column = 0;
     89   unsigned Item = 0;
     90   while (State.NextToken != LBrace->MatchingParen) {
     91     bool NewLine = false;
     92     unsigned ExtraSpaces = 0;
     93 
     94     // If the previous token was one of our commas, we are now on the next item.
     95     if (Item < Commas.size() && State.NextToken->Previous == Commas[Item]) {
     96       if (!State.NextToken->isTrailingComment()) {
     97         ExtraSpaces += Format->ColumnSizes[Column] - ItemLengths[Item];
     98         ++Column;
     99       }
    100       ++Item;
    101     }
    102 
    103     if (Column == Format->Columns || State.NextToken->MustBreakBefore) {
    104       Column = 0;
    105       NewLine = true;
    106     }
    107 
    108     // Place token using the continuation indenter and store the penalty.
    109     Penalty += Indenter->addTokenToState(State, NewLine, DryRun, ExtraSpaces);
    110   }
    111   return Penalty;
    112 }
    113 
    114 unsigned CommaSeparatedList::formatFromToken(LineState &State,
    115                                              ContinuationIndenter *Indenter,
    116                                              bool DryRun) {
    117   if (HasNestedBracedList)
    118     State.Stack.back().AvoidBinPacking = true;
    119   return 0;
    120 }
    121 
    122 // Returns the lengths in code points between Begin and End (both included),
    123 // assuming that the entire sequence is put on a single line.
    124 static unsigned CodePointsBetween(const FormatToken *Begin,
    125                                   const FormatToken *End) {
    126   assert(End->TotalLength >= Begin->TotalLength);
    127   return End->TotalLength - Begin->TotalLength + Begin->ColumnWidth;
    128 }
    129 
    130 void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) {
    131   // FIXME: At some point we might want to do this for other lists, too.
    132   if (!Token->MatchingParen || Token->isNot(tok::l_brace))
    133     return;
    134 
    135   // In C++11 braced list style, we should not format in columns unless they
    136   // have many items (20 or more) or we allow bin-packing of function
    137   // parameters.
    138   if (Style.Cpp11BracedListStyle && !Style.BinPackParameters &&
    139       Commas.size() < 19)
    140     return;
    141 
    142   // Column format doesn't really make sense if we don't align after brackets.
    143   if (!Style.AlignAfterOpenBracket)
    144     return;
    145 
    146   FormatToken *ItemBegin = Token->Next;
    147   SmallVector<bool, 8> MustBreakBeforeItem;
    148 
    149   // The lengths of an item if it is put at the end of the line. This includes
    150   // trailing comments which are otherwise ignored for column alignment.
    151   SmallVector<unsigned, 8> EndOfLineItemLength;
    152 
    153   unsigned MinItemLength = Style.ColumnLimit;
    154   unsigned MaxItemLength = 0;
    155 
    156   for (unsigned i = 0, e = Commas.size() + 1; i != e; ++i) {
    157     // Skip comments on their own line.
    158     while (ItemBegin->HasUnescapedNewline && ItemBegin->isTrailingComment())
    159       ItemBegin = ItemBegin->Next;
    160 
    161     MustBreakBeforeItem.push_back(ItemBegin->MustBreakBefore);
    162     if (ItemBegin->is(tok::l_brace))
    163       HasNestedBracedList = true;
    164     const FormatToken *ItemEnd = nullptr;
    165     if (i == Commas.size()) {
    166       ItemEnd = Token->MatchingParen;
    167       const FormatToken *NonCommentEnd = ItemEnd->getPreviousNonComment();
    168       ItemLengths.push_back(CodePointsBetween(ItemBegin, NonCommentEnd));
    169       if (Style.Cpp11BracedListStyle) {
    170         // In Cpp11 braced list style, the } and possibly other subsequent
    171         // tokens will need to stay on a line with the last element.
    172         while (ItemEnd->Next && !ItemEnd->Next->CanBreakBefore)
    173           ItemEnd = ItemEnd->Next;
    174       } else {
    175         // In other braced lists styles, the "}" can be wrapped to the new line.
    176         ItemEnd = Token->MatchingParen->Previous;
    177       }
    178     } else {
    179       ItemEnd = Commas[i];
    180       // The comma is counted as part of the item when calculating the length.
    181       ItemLengths.push_back(CodePointsBetween(ItemBegin, ItemEnd));
    182       MinItemLength = std::min(MinItemLength, ItemLengths.back());
    183       MaxItemLength = std::max(MaxItemLength, ItemLengths.back());
    184 
    185       // Consume trailing comments so the are included in EndOfLineItemLength.
    186       if (ItemEnd->Next && !ItemEnd->Next->HasUnescapedNewline &&
    187           ItemEnd->Next->isTrailingComment())
    188         ItemEnd = ItemEnd->Next;
    189     }
    190     EndOfLineItemLength.push_back(CodePointsBetween(ItemBegin, ItemEnd));
    191     // If there is a trailing comma in the list, the next item will start at the
    192     // closing brace. Don't create an extra item for this.
    193     if (ItemEnd->getNextNonComment() == Token->MatchingParen)
    194       break;
    195     ItemBegin = ItemEnd->Next;
    196   }
    197 
    198   // If this doesn't have a nested list, we require at least 6 elements in order
    199   // create a column layout. If it has a nested list, column layout ensures one
    200   // list element per line. If the difference between the shortest and longest
    201   // element is too large, column layout would create too much whitespace.
    202   if (HasNestedBracedList || Commas.size() < 5 || Token->NestingLevel != 0 ||
    203       MaxItemLength - MinItemLength > 10)
    204     return;
    205 
    206   // We can never place more than ColumnLimit / 3 items in a row (because of the
    207   // spaces and the comma).
    208   for (unsigned Columns = 1; Columns <= Style.ColumnLimit / 3; ++Columns) {
    209     ColumnFormat Format;
    210     Format.Columns = Columns;
    211     Format.ColumnSizes.resize(Columns);
    212     Format.LineCount = 1;
    213     bool HasRowWithSufficientColumns = false;
    214     unsigned Column = 0;
    215     for (unsigned i = 0, e = ItemLengths.size(); i != e; ++i) {
    216       assert(i < MustBreakBeforeItem.size());
    217       if (MustBreakBeforeItem[i] || Column == Columns) {
    218         ++Format.LineCount;
    219         Column = 0;
    220       }
    221       if (Column == Columns - 1)
    222         HasRowWithSufficientColumns = true;
    223       unsigned length =
    224           (Column == Columns - 1) ? EndOfLineItemLength[i] : ItemLengths[i];
    225       Format.ColumnSizes[Column] = std::max(Format.ColumnSizes[Column], length);
    226       ++Column;
    227     }
    228     // If all rows are terminated early (e.g. by trailing comments), we don't
    229     // need to look further.
    230     if (!HasRowWithSufficientColumns)
    231       break;
    232     Format.TotalWidth = Columns - 1; // Width of the N-1 spaces.
    233     for (unsigned i = 0; i < Columns; ++i) {
    234       Format.TotalWidth += Format.ColumnSizes[i];
    235     }
    236 
    237     // Ignore layouts that are bound to violate the column limit.
    238     if (Format.TotalWidth > Style.ColumnLimit)
    239       continue;
    240 
    241     Formats.push_back(Format);
    242   }
    243 }
    244 
    245 const CommaSeparatedList::ColumnFormat *
    246 CommaSeparatedList::getColumnFormat(unsigned RemainingCharacters) const {
    247   const ColumnFormat *BestFormat = nullptr;
    248   for (SmallVector<ColumnFormat, 4>::const_reverse_iterator
    249            I = Formats.rbegin(),
    250            E = Formats.rend();
    251        I != E; ++I) {
    252     if (I->TotalWidth <= RemainingCharacters) {
    253       if (BestFormat && I->LineCount > BestFormat->LineCount)
    254         break;
    255       BestFormat = &*I;
    256     }
    257   }
    258   return BestFormat;
    259 }
    260 
    261 } // namespace format
    262 } // namespace clang
    263