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, SourceRange OriginalWhitespaceRange,
  30     unsigned IndentLevel, int Spaces, unsigned StartOfTokenColumn,
  31     unsigned NewlinesBefore, StringRef PreviousLinePostfix,
  32     StringRef CurrentLinePrefix, tok::TokenKind Kind, bool ContinuesPPDirective,
  33     bool IsStartOfDeclName)
  34     : CreateReplacement(CreateReplacement),
  35       OriginalWhitespaceRange(OriginalWhitespaceRange),
  36       StartOfTokenColumn(StartOfTokenColumn), NewlinesBefore(NewlinesBefore),
  37       PreviousLinePostfix(PreviousLinePostfix),
  38       CurrentLinePrefix(CurrentLinePrefix), Kind(Kind),
  39       ContinuesPPDirective(ContinuesPPDirective),
  40       IsStartOfDeclName(IsStartOfDeclName), IndentLevel(IndentLevel),
  41       Spaces(Spaces), IsTrailingComment(false), TokenLength(0),
  42       PreviousEndOfTokenColumn(0), EscapedNewlineColumn(0),
  43       StartOfBlockComment(nullptr), IndentationOffset(0) {}
  44
  45 void WhitespaceManager::reset() {
  46   Changes.clear();
  47   Replaces.clear();
  48 }
  49
  50 void WhitespaceManager::replaceWhitespace(FormatToken &Tok, unsigned Newlines,
  51                                           unsigned IndentLevel, unsigned Spaces,
  52                                           unsigned StartOfTokenColumn,
  53                                           bool InPPDirective) {
  54   if (Tok.Finalized)
  55     return;
  56   Tok.Decision = (Newlines > 0) ? FD_Break : FD_Continue;
  57   Changes.push_back(
  58       Change(true, Tok.WhitespaceRange, IndentLevel, Spaces, StartOfTokenColumn,
  59              Newlines, "", "", Tok.Tok.getKind(), InPPDirective && !Tok.IsFirst,
  60              Tok.is(TT_StartOfName) || Tok.is(TT_FunctionDeclarationName)));
  61 }
  62
  63 void WhitespaceManager::addUntouchableToken(const FormatToken &Tok,
  64                                             bool InPPDirective) {
  65   if (Tok.Finalized)
  66     return;
  67   Changes.push_back(
  68       Change(false, Tok.WhitespaceRange, /*IndentLevel=*/0,
  69              /*Spaces=*/0, Tok.OriginalColumn, Tok.NewlinesBefore, "", "",
  70              Tok.Tok.getKind(), InPPDirective && !Tok.IsFirst,
  71              Tok.is(TT_StartOfName) || Tok.is(TT_FunctionDeclarationName)));
  72 }
  73
  74 void WhitespaceManager::replaceWhitespaceInToken(
  75     const FormatToken &Tok, unsigned Offset, unsigned ReplaceChars,
  76     StringRef PreviousPostfix, StringRef CurrentPrefix, bool InPPDirective,
  77     unsigned Newlines, unsigned IndentLevel, int Spaces) {
  78   if (Tok.Finalized)
  79     return;
  80   SourceLocation Start = Tok.getStartOfNonWhitespace().getLocWithOffset(Offset);
  81   Changes.push_back(Change(
  82       true, SourceRange(Start, Start.getLocWithOffset(ReplaceChars)),
  83       IndentLevel, Spaces, std::max(0, Spaces), Newlines, PreviousPostfix,
  84       CurrentPrefix,
  85       // If we don't add a newline this change doesn't start a comment. Thus,
  86       // when we align line comments, we don't need to treat this change as one.
  87       // FIXME: We still need to take this change in account to properly
  88       // calculate the new length of the comment and to calculate the changes
  89       // for which to do the alignment when aligning comments.
  90       Tok.is(TT_LineComment) && Newlines > 0 ? tok::comment : tok::unknown,
  91       InPPDirective && !Tok.IsFirst,
  92       Tok.is(TT_StartOfName) || Tok.is(TT_FunctionDeclarationName)));
  93 }
  94
  95 const tooling::Replacements &WhitespaceManager::generateReplacements() {
  96   if (Changes.empty())
  97     return Replaces;
  98
  99   std::sort(Changes.begin(), Changes.end(), Change::IsBeforeInFile(SourceMgr));
 100   calculateLineBreakInformation();
 101   alignConsecutiveDeclarations();
 102   alignConsecutiveAssignments();
 103   alignTrailingComments();
 104   alignEscapedNewlines();
 105   generateChanges();
 106
 107   return Replaces;
 108 }
 109
 110 void WhitespaceManager::calculateLineBreakInformation() {
 111   Changes[0].PreviousEndOfTokenColumn = 0;
 112   for (unsigned i = 1, e = Changes.size(); i != e; ++i) {
 113     unsigned OriginalWhitespaceStart =
 114         SourceMgr.getFileOffset(Changes[i].OriginalWhitespaceRange.getBegin());
 115     unsigned PreviousOriginalWhitespaceEnd = SourceMgr.getFileOffset(
 116         Changes[i - 1].OriginalWhitespaceRange.getEnd());
 117     Changes[i - 1].TokenLength = OriginalWhitespaceStart -
 118                                  PreviousOriginalWhitespaceEnd +
 119                                  Changes[i].PreviousLinePostfix.size() +
 120                                  Changes[i - 1].CurrentLinePrefix.size();
 121
 122     Changes[i].PreviousEndOfTokenColumn =
 123         Changes[i - 1].StartOfTokenColumn + Changes[i - 1].TokenLength;
 124
 125     Changes[i - 1].IsTrailingComment =
 126         (Changes[i].NewlinesBefore > 0 || Changes[i].Kind == tok::eof) &&
 127         Changes[i - 1].Kind == tok::comment;
 128   }
 129   // FIXME: The last token is currently not always an eof token; in those
 130   // cases, setting TokenLength of the last token to 0 is wrong.
 131   Changes.back().TokenLength = 0;
 132   Changes.back().IsTrailingComment = Changes.back().Kind == tok::comment;
 133
 134   const WhitespaceManager::Change *LastBlockComment = nullptr;
 135   for (auto &Change : Changes) {
 136     Change.StartOfBlockComment = nullptr;
 137     Change.IndentationOffset = 0;
 138     if (Change.Kind == tok::comment) {
 139       LastBlockComment = &Change;
 140     } else if (Change.Kind == tok::unknown) {
 141       if ((Change.StartOfBlockComment = LastBlockComment))
 142         Change.IndentationOffset =
 143             Change.StartOfTokenColumn -
 144             Change.StartOfBlockComment->StartOfTokenColumn;
 145     } else {
 146       LastBlockComment = nullptr;
 147     }
 148   }
 149 }
 150
 151 // Align a single sequence of tokens, see AlignTokens below.
 152 template <typename F>
 153 static void
 154 AlignTokenSequence(unsigned Start, unsigned End, unsigned Column, F &&Matches,
 155                    SmallVector<WhitespaceManager::Change, 16> &Changes) {
 156   bool FoundMatchOnLine = false;
 157   int Shift = 0;
 158   for (unsigned i = Start; i != End; ++i) {
 159     if (Changes[i].NewlinesBefore > 0) {
 160       FoundMatchOnLine = false;
 161       Shift = 0;
 162     }
 163
 164     // If this is the first matching token to be aligned, remember by how many
 165     // spaces it has to be shifted, so the rest of the changes on the line are
 166     // shifted by the same amount
 167     if (!FoundMatchOnLine && Matches(Changes[i])) {
 168       FoundMatchOnLine = true;
 169       Shift = Column - Changes[i].StartOfTokenColumn;
 170       Changes[i].Spaces += Shift;
 171     }
 172
 173     assert(Shift >= 0);
 174     Changes[i].StartOfTokenColumn += Shift;
 175     if (i + 1 != Changes.size())
 176       Changes[i + 1].PreviousEndOfTokenColumn += Shift;
 177   }
 178 }
 179
 180 // Walk through all of the changes and find sequences of matching tokens to
 181 // align. To do so, keep track of the lines and whether or not a matching token
 182 // was found on a line. If a matching token is found, extend the current
 183 // sequence. If the current line cannot be part of a sequence, e.g. because
 184 // there is an empty line before it or it contains only non-matching tokens,
 185 // finalize the previous sequence.
 186 template <typename F>
 187 static void AlignTokens(const FormatStyle &Style, F &&Matches,
 188                         SmallVector<WhitespaceManager::Change, 16> &Changes) {
 189   unsigned MinColumn = 0;
 190   unsigned MaxColumn = UINT_MAX;
 191
 192   // Line number of the start and the end of the current token sequence.
 193   unsigned StartOfSequence = 0;
 194   unsigned EndOfSequence = 0;
 195
 196   // Keep track of the nesting level of matching tokens, i.e. the number of
 197   // surrounding (), [], or {}. We will only align a sequence of matching
 198   // token that share the same scope depth.
 199   //
 200   // FIXME: This could use FormatToken::NestingLevel information, but there is
 201   // an outstanding issue wrt the brace scopes.
 202   unsigned NestingLevelOfLastMatch = 0;
 203   unsigned NestingLevel = 0;
 204
 205   // Keep track of the number of commas before the matching tokens, we will only
 206   // align a sequence of matching tokens if they are preceded by the same number
 207   // of commas.
 208   unsigned CommasBeforeLastMatch = 0;
 209   unsigned CommasBeforeMatch = 0;
 210
 211   // Whether a matching token has been found on the current line.
 212   bool FoundMatchOnLine = false;
 213
 214   // Aligns a sequence of matching tokens, on the MinColumn column.
 215   //
 216   // Sequences start from the first matching token to align, and end at the
 217   // first token of the first line that doesn't need to be aligned.
 218   //
 219   // We need to adjust the StartOfTokenColumn of each Change that is on a line
 220   // containing any matching token to be aligned and located after such token.
 221   auto AlignCurrentSequence = [&] {
 222     if (StartOfSequence > 0 && StartOfSequence < EndOfSequence)
 223       AlignTokenSequence(StartOfSequence, EndOfSequence, MinColumn, Matches,
 224                          Changes);
 225     MinColumn = 0;
 226     MaxColumn = UINT_MAX;
 227     StartOfSequence = 0;
 228     EndOfSequence = 0;
 229   };
 230
 231   for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
 232     if (Changes[i].NewlinesBefore != 0) {
 233       CommasBeforeMatch = 0;
 234       EndOfSequence = i;
 235       // If there is a blank line, or if the last line didn't contain any
 236       // matching token, the sequence ends here.
 237       if (Changes[i].NewlinesBefore > 1 || !FoundMatchOnLine)
 238         AlignCurrentSequence();
 239
 240       FoundMatchOnLine = false;
 241     }
 242
 243     if (Changes[i].Kind == tok::comma) {
 244       ++CommasBeforeMatch;
 245     } else if (Changes[i].Kind == tok::r_brace ||
 246                Changes[i].Kind == tok::r_paren ||
 247                Changes[i].Kind == tok::r_square) {
 248       --NestingLevel;
 249     } else if (Changes[i].Kind == tok::l_brace ||
 250                Changes[i].Kind == tok::l_paren ||
 251                Changes[i].Kind == tok::l_square) {
 252       // We want sequences to skip over child scopes if possible, but not the
 253       // other way around.
 254       NestingLevelOfLastMatch = std::min(NestingLevelOfLastMatch, NestingLevel);
 255       ++NestingLevel;
 256     }
 257
 258     if (!Matches(Changes[i]))
 259       continue;
 260
 261     // If there is more than one matching token per line, or if the number of
 262     // preceding commas, or the scope depth, do not match anymore, end the
 263     // sequence.
 264     if (FoundMatchOnLine || CommasBeforeMatch != CommasBeforeLastMatch ||
 265         NestingLevel != NestingLevelOfLastMatch)
 266       AlignCurrentSequence();
 267
 268     CommasBeforeLastMatch = CommasBeforeMatch;
 269     NestingLevelOfLastMatch = NestingLevel;
 270     FoundMatchOnLine = true;
 271
 272     if (StartOfSequence == 0)
 273       StartOfSequence = i;
 274
 275     unsigned ChangeMinColumn = Changes[i].StartOfTokenColumn;
 276     int LineLengthAfter = -Changes[i].Spaces;
 277     for (unsigned j = i; j != e && Changes[j].NewlinesBefore == 0; ++j)
 278       LineLengthAfter += Changes[j].Spaces + Changes[j].TokenLength;
 279     unsigned ChangeMaxColumn = Style.ColumnLimit - LineLengthAfter;
 280
 281     // If we are restricted by the maximum column width, end the sequence.
 282     if (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn ||
 283         CommasBeforeLastMatch != CommasBeforeMatch) {
 284       AlignCurrentSequence();
 285       StartOfSequence = i;
 286     }
 287
 288     MinColumn = std::max(MinColumn, ChangeMinColumn);
 289     MaxColumn = std::min(MaxColumn, ChangeMaxColumn);
 290   }
 291
 292   EndOfSequence = Changes.size();
 293   AlignCurrentSequence();
 294 }
 295
 296 void WhitespaceManager::alignConsecutiveAssignments() {
 297   if (!Style.AlignConsecutiveAssignments)
 298     return;
 299
 300   AlignTokens(Style,
 301               [&](const Change &C) {
 302                 // Do not align on equal signs that are first on a line.
 303                 if (C.NewlinesBefore > 0)
 304                   return false;
 305
 306                 // Do not align on equal signs that are last on a line.
 307                 if (&C != &Changes.back() && (&C + 1)->NewlinesBefore > 0)
 308                   return false;
 309
 310                 return C.Kind == tok::equal;
 311               },
 312               Changes);
 313 }
 314
 315 void WhitespaceManager::alignConsecutiveDeclarations() {
 316   if (!Style.AlignConsecutiveDeclarations)
 317     return;
 318
 319   // FIXME: Currently we don't handle properly the PointerAlignment: Right
 320   // The * and & are not aligned and are left dangling. Something has to be done
 321   // about it, but it raises the question of alignment of code like:
 322   //   const char* const* v1;
 323   //   float const* v2;
 324   //   SomeVeryLongType const& v3;
 325
 326   AlignTokens(Style, [](Change const &C) { return C.IsStartOfDeclName; },
 327               Changes);
 328 }
 329
 330 void WhitespaceManager::alignTrailingComments() {
 331   unsigned MinColumn = 0;
 332   unsigned MaxColumn = UINT_MAX;
 333   unsigned StartOfSequence = 0;
 334   bool BreakBeforeNext = false;
 335   unsigned Newlines = 0;
 336   for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
 337     if (Changes[i].StartOfBlockComment)
 338       continue;
 339     Newlines += Changes[i].NewlinesBefore;
 340     if (!Changes[i].IsTrailingComment)
 341       continue;
 342
 343     unsigned ChangeMinColumn = Changes[i].StartOfTokenColumn;
 344     unsigned ChangeMaxColumn = Style.ColumnLimit - Changes[i].TokenLength;
 345     if (i + 1 != e && Changes[i + 1].ContinuesPPDirective)
 346       ChangeMaxColumn -= 2;
 347     // If this comment follows an } in column 0, it probably documents the
 348     // closing of a namespace and we don't want to align it.
 349     bool FollowsRBraceInColumn0 = i > 0 && Changes[i].NewlinesBefore == 0 &&
 350                                   Changes[i - 1].Kind == tok::r_brace &&
 351                                   Changes[i - 1].StartOfTokenColumn == 0;
 352     bool WasAlignedWithStartOfNextLine = false;
 353     if (Changes[i].NewlinesBefore == 1) { // A comment on its own line.
 354       unsigned CommentColumn = SourceMgr.getSpellingColumnNumber(
 355           Changes[i].OriginalWhitespaceRange.getEnd());
 356       for (unsigned j = i + 1; j != e; ++j) {
 357         if (Changes[j].Kind != tok::comment) { // Skip over comments.
 358           unsigned NextColumn = SourceMgr.getSpellingColumnNumber(
 359               Changes[j].OriginalWhitespaceRange.getEnd());
 360           // The start of the next token was previously aligned with the
 361           // start of this comment.
 362           WasAlignedWithStartOfNextLine =
 363               CommentColumn == NextColumn ||
 364               CommentColumn == NextColumn + Style.IndentWidth;
 365           break;
 366         }
 367       }
 368     }
 369     if (!Style.AlignTrailingComments || FollowsRBraceInColumn0) {
 370       alignTrailingComments(StartOfSequence, i, MinColumn);
 371       MinColumn = ChangeMinColumn;
 372       MaxColumn = ChangeMinColumn;
 373       StartOfSequence = i;
 374     } else if (BreakBeforeNext || Newlines > 1 ||
 375                (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn) ||
 376                // Break the comment sequence if the previous line did not end
 377                // in a trailing comment.
 378                (Changes[i].NewlinesBefore == 1 && i > 0 &&
 379                 !Changes[i - 1].IsTrailingComment) ||
 380                WasAlignedWithStartOfNextLine) {
 381       alignTrailingComments(StartOfSequence, i, MinColumn);
 382       MinColumn = ChangeMinColumn;
 383       MaxColumn = ChangeMaxColumn;
 384       StartOfSequence = i;
 385     } else {
 386       MinColumn = std::max(MinColumn, ChangeMinColumn);
 387       MaxColumn = std::min(MaxColumn, ChangeMaxColumn);
 388     }
 389     BreakBeforeNext =
 390         (i == 0) || (Changes[i].NewlinesBefore > 1) ||
 391         // Never start a sequence with a comment at the beginning of
 392         // the line.
 393         (Changes[i].NewlinesBefore == 1 && StartOfSequence == i);
 394     Newlines = 0;
 395   }
 396   alignTrailingComments(StartOfSequence, Changes.size(), MinColumn);
 397 }
 398
 399 void WhitespaceManager::alignTrailingComments(unsigned Start, unsigned End,
 400                                               unsigned Column) {
 401   for (unsigned i = Start; i != End; ++i) {
 402     int Shift = 0;
 403     if (Changes[i].IsTrailingComment) {
 404       Shift = Column - Changes[i].StartOfTokenColumn;
 405     }
 406     if (Changes[i].StartOfBlockComment) {
 407       Shift = Changes[i].IndentationOffset +
 408               Changes[i].StartOfBlockComment->StartOfTokenColumn -
 409               Changes[i].StartOfTokenColumn;
 410     }
 411     assert(Shift >= 0);
 412     Changes[i].Spaces += Shift;
 413     if (i + 1 != End)
 414       Changes[i + 1].PreviousEndOfTokenColumn += Shift;
 415     Changes[i].StartOfTokenColumn += Shift;
 416   }
 417 }
 418
 419 void WhitespaceManager::alignEscapedNewlines() {
 420   unsigned MaxEndOfLine =
 421       Style.AlignEscapedNewlinesLeft ? 0 : Style.ColumnLimit;
 422   unsigned StartOfMacro = 0;
 423   for (unsigned i = 1, e = Changes.size(); i < e; ++i) {
 424     Change &C = Changes[i];
 425     if (C.NewlinesBefore > 0) {
 426       if (C.ContinuesPPDirective) {
 427         MaxEndOfLine = std::max(C.PreviousEndOfTokenColumn + 2, MaxEndOfLine);
 428       } else {
 429         alignEscapedNewlines(StartOfMacro + 1, i, MaxEndOfLine);
 430         MaxEndOfLine = Style.AlignEscapedNewlinesLeft ? 0 : Style.ColumnLimit;
 431         StartOfMacro = i;
 432       }
 433     }
 434   }
 435   alignEscapedNewlines(StartOfMacro + 1, Changes.size(), MaxEndOfLine);
 436 }
 437
 438 void WhitespaceManager::alignEscapedNewlines(unsigned Start, unsigned End,
 439                                              unsigned Column) {
 440   for (unsigned i = Start; i < End; ++i) {
 441     Change &C = Changes[i];
 442     if (C.NewlinesBefore > 0) {
 443       assert(C.ContinuesPPDirective);
 444       if (C.PreviousEndOfTokenColumn + 1 > Column)
 445         C.EscapedNewlineColumn = 0;
 446       else
 447         C.EscapedNewlineColumn = Column;
 448     }
 449   }
 450 }
 451
 452 void WhitespaceManager::generateChanges() {
 453   for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
 454     const Change &C = Changes[i];
 455     if (i > 0) {
 456       assert(Changes[i - 1].OriginalWhitespaceRange.getBegin() !=
 457                  C.OriginalWhitespaceRange.getBegin() &&
 458              "Generating two replacements for the same location");
 459     }
 460     if (C.CreateReplacement) {
 461       std::string ReplacementText = C.PreviousLinePostfix;
 462       if (C.ContinuesPPDirective)
 463         appendNewlineText(ReplacementText, C.NewlinesBefore,
 464                           C.PreviousEndOfTokenColumn, C.EscapedNewlineColumn);
 465       else
 466         appendNewlineText(ReplacementText, C.NewlinesBefore);
 467       appendIndentText(ReplacementText, C.IndentLevel, std::max(0, C.Spaces),
 468                        C.StartOfTokenColumn - std::max(0, C.Spaces));
 469       ReplacementText.append(C.CurrentLinePrefix);
 470       storeReplacement(C.OriginalWhitespaceRange, ReplacementText);
 471     }
 472   }
 473 }
 474
 475 void WhitespaceManager::storeReplacement(SourceRange Range,
 476                                          StringRef Text) {
 477   unsigned WhitespaceLength = SourceMgr.getFileOffset(Range.getEnd()) -
 478                               SourceMgr.getFileOffset(Range.getBegin());
 479   // Don't create a replacement, if it does not change anything.
 480   if (StringRef(SourceMgr.getCharacterData(Range.getBegin()),
 481                 WhitespaceLength) == Text)
 482     return;
 483   Replaces.insert(tooling::Replacement(
 484       SourceMgr, CharSourceRange::getCharRange(Range), Text));
 485 }
 486
 487 void WhitespaceManager::appendNewlineText(std::string &Text,
 488                                           unsigned Newlines) {
 489   for (unsigned i = 0; i < Newlines; ++i)
 490     Text.append(UseCRLF ? "\r\n" : "\n");
 491 }
 492
 493 void WhitespaceManager::appendNewlineText(std::string &Text, unsigned Newlines,
 494                                           unsigned PreviousEndOfTokenColumn,
 495                                           unsigned EscapedNewlineColumn) {
 496   if (Newlines > 0) {
 497     unsigned Offset =
 498         std::min<int>(EscapedNewlineColumn - 1, PreviousEndOfTokenColumn);
 499     for (unsigned i = 0; i < Newlines; ++i) {
 500       Text.append(EscapedNewlineColumn - Offset - 1, ' ');
 501       Text.append(UseCRLF ? "\\\r\n" : "\\\n");
 502       Offset = 0;
 503     }
 504   }
 505 }
 506
 507 void WhitespaceManager::appendIndentText(std::string &Text,
 508                                          unsigned IndentLevel, unsigned Spaces,
 509                                          unsigned WhitespaceStartColumn) {
 510   switch (Style.UseTab) {
 511   case FormatStyle::UT_Never:
 512     Text.append(Spaces, ' ');
 513     break;
 514   case FormatStyle::UT_Always: {
 515     unsigned FirstTabWidth =
 516         Style.TabWidth - WhitespaceStartColumn % Style.TabWidth;
 517     // Indent with tabs only when there's at least one full tab.
 518     if (FirstTabWidth + Style.TabWidth <= Spaces) {
 519       Spaces -= FirstTabWidth;
 520       Text.append("\t");
 521     }
 522     Text.append(Spaces / Style.TabWidth, '\t');
 523     Text.append(Spaces % Style.TabWidth, ' ');
 524     break;
 525   }
 526   case FormatStyle::UT_ForIndentation:
 527     if (WhitespaceStartColumn == 0) {
 528       unsigned Indentation = IndentLevel * Style.IndentWidth;
 529       // This happens, e.g. when a line in a block comment is indented less than
 530       // the first one.
 531       if (Indentation > Spaces)
 532         Indentation = Spaces;
 533       unsigned Tabs = Indentation / Style.TabWidth;
 534       Text.append(Tabs, '\t');
 535       Spaces -= Tabs * Style.TabWidth;
 536     }
 537     Text.append(Spaces, ' ');
 538     break;
 539   }
 540 }
 541
 542 } // namespace format
 543 } // namespace clang