contrib/llvm/tools/clang/lib/Format/WhitespaceManager.cpp

   1 //===--- WhitespaceManager.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 WhitespaceManager class.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "WhitespaceManager.h"
  16 #include "llvm/ADT/STLExtras.h"
  17
  18 namespace clang {
  19 namespace format {
  20
  21 bool WhitespaceManager::Change::IsBeforeInFile::
  22 operator()(const Change &C1, const Change &C2) const {
  23   return SourceMgr.isBeforeInTranslationUnit(
  24       C1.OriginalWhitespaceRange.getBegin(),
  25       C2.OriginalWhitespaceRange.getBegin());
  26 }
  27
  28 WhitespaceManager::Change::Change(
  29     bool CreateReplacement, const SourceRange &OriginalWhitespaceRange,
  30     unsigned IndentLevel, int Spaces, unsigned StartOfTokenColumn,
  31     unsigned NewlinesBefore, StringRef PreviousLinePostfix,
  32     StringRef CurrentLinePrefix, tok::TokenKind Kind, bool ContinuesPPDirective)
  33     : CreateReplacement(CreateReplacement),
  34       OriginalWhitespaceRange(OriginalWhitespaceRange),
  35       StartOfTokenColumn(StartOfTokenColumn), NewlinesBefore(NewlinesBefore),
  36       PreviousLinePostfix(PreviousLinePostfix),
  37       CurrentLinePrefix(CurrentLinePrefix), Kind(Kind),
  38       ContinuesPPDirective(ContinuesPPDirective), IndentLevel(IndentLevel),
  39       Spaces(Spaces) {}
  40
  41 void WhitespaceManager::reset() {
  42   Changes.clear();
  43   Replaces.clear();
  44 }
  45
  46 void WhitespaceManager::replaceWhitespace(FormatToken &Tok, unsigned Newlines,
  47                                           unsigned IndentLevel, unsigned Spaces,
  48                                           unsigned StartOfTokenColumn,
  49                                           bool InPPDirective) {
  50   if (Tok.Finalized)
  51     return;
  52   Tok.Decision = (Newlines > 0) ? FD_Break : FD_Continue;
  53   Changes.push_back(Change(true, Tok.WhitespaceRange, IndentLevel, Spaces,
  54                            StartOfTokenColumn, Newlines, "", "",
  55                            Tok.Tok.getKind(), InPPDirective && !Tok.IsFirst));
  56 }
  57
  58 void WhitespaceManager::addUntouchableToken(const FormatToken &Tok,
  59                                             bool InPPDirective) {
  60   if (Tok.Finalized)
  61     return;
  62   Changes.push_back(Change(false, Tok.WhitespaceRange, /*IndentLevel=*/0,
  63                            /*Spaces=*/0, Tok.OriginalColumn, Tok.NewlinesBefore,
  64                            "", "", Tok.Tok.getKind(),
  65                            InPPDirective && !Tok.IsFirst));
  66 }
  67
  68 void WhitespaceManager::replaceWhitespaceInToken(
  69     const FormatToken &Tok, unsigned Offset, unsigned ReplaceChars,
  70     StringRef PreviousPostfix, StringRef CurrentPrefix, bool InPPDirective,
  71     unsigned Newlines, unsigned IndentLevel, int Spaces) {
  72   if (Tok.Finalized)
  73     return;
  74   SourceLocation Start = Tok.getStartOfNonWhitespace().getLocWithOffset(Offset);
  75   Changes.push_back(Change(
  76       true, SourceRange(Start, Start.getLocWithOffset(ReplaceChars)),
  77       IndentLevel, Spaces, std::max(0, Spaces), Newlines, PreviousPostfix,
  78       CurrentPrefix,
  79       // If we don't add a newline this change doesn't start a comment. Thus,
  80       // when we align line comments, we don't need to treat this change as one.
  81       // FIXME: We still need to take this change in account to properly
  82       // calculate the new length of the comment and to calculate the changes
  83       // for which to do the alignment when aligning comments.
  84       Tok.Type == TT_LineComment && Newlines > 0 ? tok::comment : tok::unknown,
  85       InPPDirective && !Tok.IsFirst));
  86 }
  87
  88 const tooling::Replacements &WhitespaceManager::generateReplacements() {
  89   if (Changes.empty())
  90     return Replaces;
  91
  92   std::sort(Changes.begin(), Changes.end(), Change::IsBeforeInFile(SourceMgr));
  93   calculateLineBreakInformation();
  94   alignTrailingComments();
  95   alignEscapedNewlines();
  96   generateChanges();
  97
  98   return Replaces;
  99 }
 100
 101 void WhitespaceManager::calculateLineBreakInformation() {
 102   Changes[0].PreviousEndOfTokenColumn = 0;
 103   for (unsigned i = 1, e = Changes.size(); i != e; ++i) {
 104     unsigned OriginalWhitespaceStart =
 105         SourceMgr.getFileOffset(Changes[i].OriginalWhitespaceRange.getBegin());
 106     unsigned PreviousOriginalWhitespaceEnd = SourceMgr.getFileOffset(
 107         Changes[i - 1].OriginalWhitespaceRange.getEnd());
 108     Changes[i - 1].TokenLength = OriginalWhitespaceStart -
 109                                  PreviousOriginalWhitespaceEnd +
 110                                  Changes[i].PreviousLinePostfix.size() +
 111                                  Changes[i - 1].CurrentLinePrefix.size();
 112
 113     Changes[i].PreviousEndOfTokenColumn =
 114         Changes[i - 1].StartOfTokenColumn + Changes[i - 1].TokenLength;
 115
 116     Changes[i - 1].IsTrailingComment =
 117         (Changes[i].NewlinesBefore > 0 || Changes[i].Kind == tok::eof) &&
 118         Changes[i - 1].Kind == tok::comment;
 119   }
 120   // FIXME: The last token is currently not always an eof token; in those
 121   // cases, setting TokenLength of the last token to 0 is wrong.
 122   Changes.back().TokenLength = 0;
 123   Changes.back().IsTrailingComment = Changes.back().Kind == tok::comment;
 124
 125   const WhitespaceManager::Change *LastBlockComment = nullptr;
 126   for (auto &Change : Changes) {
 127     Change.StartOfBlockComment = nullptr;
 128     Change.IndentationOffset = 0;
 129     if (Change.Kind == tok::comment) {
 130       LastBlockComment = &Change;
 131     } else if (Change.Kind == tok::unknown) {
 132       if ((Change.StartOfBlockComment = LastBlockComment))
 133         Change.IndentationOffset =
 134             Change.StartOfTokenColumn -
 135             Change.StartOfBlockComment->StartOfTokenColumn;
 136     } else {
 137       LastBlockComment = nullptr;
 138     }
 139   }
 140 }
 141
 142 void WhitespaceManager::alignTrailingComments() {
 143   unsigned MinColumn = 0;
 144   unsigned MaxColumn = UINT_MAX;
 145   unsigned StartOfSequence = 0;
 146   bool BreakBeforeNext = false;
 147   unsigned Newlines = 0;
 148   for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
 149     if (Changes[i].StartOfBlockComment)
 150       continue;
 151     Newlines += Changes[i].NewlinesBefore;
 152     if (!Changes[i].IsTrailingComment)
 153       continue;
 154
 155     unsigned ChangeMinColumn = Changes[i].StartOfTokenColumn;
 156     unsigned ChangeMaxColumn = Style.ColumnLimit - Changes[i].TokenLength;
 157     if (i + 1 != e && Changes[i + 1].ContinuesPPDirective)
 158       ChangeMaxColumn -= 2;
 159     // If this comment follows an } in column 0, it probably documents the
 160     // closing of a namespace and we don't want to align it.
 161     bool FollowsRBraceInColumn0 = i > 0 && Changes[i].NewlinesBefore == 0 &&
 162                                   Changes[i - 1].Kind == tok::r_brace &&
 163                                   Changes[i - 1].StartOfTokenColumn == 0;
 164     bool WasAlignedWithStartOfNextLine = false;
 165     if (Changes[i].NewlinesBefore == 1) { // A comment on its own line.
 166       for (unsigned j = i + 1; j != e; ++j) {
 167         if (Changes[j].Kind != tok::comment) { // Skip over comments.
 168           // The start of the next token was previously aligned with the
 169           // start of this comment.
 170           WasAlignedWithStartOfNextLine =
 171               (SourceMgr.getSpellingColumnNumber(
 172                    Changes[i].OriginalWhitespaceRange.getEnd()) ==
 173                SourceMgr.getSpellingColumnNumber(
 174                    Changes[j].OriginalWhitespaceRange.getEnd()));
 175           break;
 176         }
 177       }
 178     }
 179     if (!Style.AlignTrailingComments || FollowsRBraceInColumn0) {
 180       alignTrailingComments(StartOfSequence, i, MinColumn);
 181       MinColumn = ChangeMinColumn;
 182       MaxColumn = ChangeMinColumn;
 183       StartOfSequence = i;
 184     } else if (BreakBeforeNext || Newlines > 1 ||
 185                (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn) ||
 186                // Break the comment sequence if the previous line did not end
 187                // in a trailing comment.
 188                (Changes[i].NewlinesBefore == 1 && i > 0 &&
 189                 !Changes[i - 1].IsTrailingComment) ||
 190                WasAlignedWithStartOfNextLine) {
 191       alignTrailingComments(StartOfSequence, i, MinColumn);
 192       MinColumn = ChangeMinColumn;
 193       MaxColumn = ChangeMaxColumn;
 194       StartOfSequence = i;
 195     } else {
 196       MinColumn = std::max(MinColumn, ChangeMinColumn);
 197       MaxColumn = std::min(MaxColumn, ChangeMaxColumn);
 198     }
 199     BreakBeforeNext =
 200         (i == 0) || (Changes[i].NewlinesBefore > 1) ||
 201         // Never start a sequence with a comment at the beginning of
 202         // the line.
 203         (Changes[i].NewlinesBefore == 1 && StartOfSequence == i);
 204     Newlines = 0;
 205   }
 206   alignTrailingComments(StartOfSequence, Changes.size(), MinColumn);
 207 }
 208
 209 void WhitespaceManager::alignTrailingComments(unsigned Start, unsigned End,
 210                                               unsigned Column) {
 211   for (unsigned i = Start; i != End; ++i) {
 212     int Shift = 0;
 213     if (Changes[i].IsTrailingComment) {
 214       Shift = Column - Changes[i].StartOfTokenColumn;
 215     }
 216     if (Changes[i].StartOfBlockComment) {
 217       Shift = Changes[i].IndentationOffset +
 218               Changes[i].StartOfBlockComment->StartOfTokenColumn -
 219               Changes[i].StartOfTokenColumn;
 220     }
 221     assert(Shift >= 0);
 222     Changes[i].Spaces += Shift;
 223     if (i + 1 != End)
 224       Changes[i + 1].PreviousEndOfTokenColumn += Shift;
 225     Changes[i].StartOfTokenColumn += Shift;
 226   }
 227 }
 228
 229 void WhitespaceManager::alignEscapedNewlines() {
 230   unsigned MaxEndOfLine =
 231       Style.AlignEscapedNewlinesLeft ? 0 : Style.ColumnLimit;
 232   unsigned StartOfMacro = 0;
 233   for (unsigned i = 1, e = Changes.size(); i < e; ++i) {
 234     Change &C = Changes[i];
 235     if (C.NewlinesBefore > 0) {
 236       if (C.ContinuesPPDirective) {
 237         MaxEndOfLine = std::max(C.PreviousEndOfTokenColumn + 2, MaxEndOfLine);
 238       } else {
 239         alignEscapedNewlines(StartOfMacro + 1, i, MaxEndOfLine);
 240         MaxEndOfLine = Style.AlignEscapedNewlinesLeft ? 0 : Style.ColumnLimit;
 241         StartOfMacro = i;
 242       }
 243     }
 244   }
 245   alignEscapedNewlines(StartOfMacro + 1, Changes.size(), MaxEndOfLine);
 246 }
 247
 248 void WhitespaceManager::alignEscapedNewlines(unsigned Start, unsigned End,
 249                                              unsigned Column) {
 250   for (unsigned i = Start; i < End; ++i) {
 251     Change &C = Changes[i];
 252     if (C.NewlinesBefore > 0) {
 253       assert(C.ContinuesPPDirective);
 254       if (C.PreviousEndOfTokenColumn + 1 > Column)
 255         C.EscapedNewlineColumn = 0;
 256       else
 257         C.EscapedNewlineColumn = Column;
 258     }
 259   }
 260 }
 261
 262 void WhitespaceManager::generateChanges() {
 263   for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
 264     const Change &C = Changes[i];
 265     if (C.CreateReplacement) {
 266       std::string ReplacementText = C.PreviousLinePostfix;
 267       if (C.ContinuesPPDirective)
 268         appendNewlineText(ReplacementText, C.NewlinesBefore,
 269                           C.PreviousEndOfTokenColumn, C.EscapedNewlineColumn);
 270       else
 271         appendNewlineText(ReplacementText, C.NewlinesBefore);
 272       appendIndentText(ReplacementText, C.IndentLevel, std::max(0, C.Spaces),
 273                        C.StartOfTokenColumn - std::max(0, C.Spaces));
 274       ReplacementText.append(C.CurrentLinePrefix);
 275       storeReplacement(C.OriginalWhitespaceRange, ReplacementText);
 276     }
 277   }
 278 }
 279
 280 void WhitespaceManager::storeReplacement(const SourceRange &Range,
 281                                          StringRef Text) {
 282   unsigned WhitespaceLength = SourceMgr.getFileOffset(Range.getEnd()) -
 283                               SourceMgr.getFileOffset(Range.getBegin());
 284   // Don't create a replacement, if it does not change anything.
 285   if (StringRef(SourceMgr.getCharacterData(Range.getBegin()),
 286                 WhitespaceLength) == Text)
 287     return;
 288   Replaces.insert(tooling::Replacement(
 289       SourceMgr, CharSourceRange::getCharRange(Range), Text));
 290 }
 291
 292 void WhitespaceManager::appendNewlineText(std::string &Text,
 293                                           unsigned Newlines) {
 294   for (unsigned i = 0; i < Newlines; ++i)
 295     Text.append(UseCRLF ? "\r\n" : "\n");
 296 }
 297
 298 void WhitespaceManager::appendNewlineText(std::string &Text, unsigned Newlines,
 299                                           unsigned PreviousEndOfTokenColumn,
 300                                           unsigned EscapedNewlineColumn) {
 301   if (Newlines > 0) {
 302     unsigned Offset =
 303         std::min<int>(EscapedNewlineColumn - 1, PreviousEndOfTokenColumn);
 304     for (unsigned i = 0; i < Newlines; ++i) {
 305       Text.append(std::string(EscapedNewlineColumn - Offset - 1, ' '));
 306       Text.append(UseCRLF ? "\\\r\n" : "\\\n");
 307       Offset = 0;
 308     }
 309   }
 310 }
 311
 312 void WhitespaceManager::appendIndentText(std::string &Text,
 313                                          unsigned IndentLevel, unsigned Spaces,
 314                                          unsigned WhitespaceStartColumn) {
 315   switch (Style.UseTab) {
 316   case FormatStyle::UT_Never:
 317     Text.append(std::string(Spaces, ' '));
 318     break;
 319   case FormatStyle::UT_Always: {
 320     unsigned FirstTabWidth =
 321         Style.TabWidth - WhitespaceStartColumn % Style.TabWidth;
 322     // Indent with tabs only when there's at least one full tab.
 323     if (FirstTabWidth + Style.TabWidth <= Spaces) {
 324       Spaces -= FirstTabWidth;
 325       Text.append("\t");
 326     }
 327     Text.append(std::string(Spaces / Style.TabWidth, '\t'));
 328     Text.append(std::string(Spaces % Style.TabWidth, ' '));
 329     break;
 330   }
 331   case FormatStyle::UT_ForIndentation:
 332     if (WhitespaceStartColumn == 0) {
 333       unsigned Indentation = IndentLevel * Style.IndentWidth;
 334       // This happens, e.g. when a line in a block comment is indented less than
 335       // the first one.
 336       if (Indentation > Spaces)
 337         Indentation = Spaces;
 338       unsigned Tabs = Indentation / Style.TabWidth;
 339       Text.append(std::string(Tabs, '\t'));
 340       Spaces -= Tabs * Style.TabWidth;
 341     }
 342     Text.append(std::string(Spaces, ' '));
 343     break;
 344   }
 345 }
 346
 347 } // namespace format
 348 } // namespace clang