1 //===--- WhitespaceManager.cpp - Format C++ code --------------------------===//
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
7 //===----------------------------------------------------------------------===//
10 /// This file implements WhitespaceManager class.
12 //===----------------------------------------------------------------------===//
14 #include "WhitespaceManager.h"
15 #include "llvm/ADT/STLExtras.h"
20 bool WhitespaceManager::Change::IsBeforeInFile::operator()(
21 const Change &C1, const Change &C2) const {
22 return SourceMgr.isBeforeInTranslationUnit(
23 C1.OriginalWhitespaceRange.getBegin(),
24 C2.OriginalWhitespaceRange.getBegin());
27 WhitespaceManager::Change::Change(const FormatToken &Tok,
28 bool CreateReplacement,
29 SourceRange OriginalWhitespaceRange,
30 int Spaces, unsigned StartOfTokenColumn,
31 unsigned NewlinesBefore,
32 StringRef PreviousLinePostfix,
33 StringRef CurrentLinePrefix, bool IsAligned,
34 bool ContinuesPPDirective, bool IsInsideToken)
35 : Tok(&Tok), CreateReplacement(CreateReplacement),
36 OriginalWhitespaceRange(OriginalWhitespaceRange),
37 StartOfTokenColumn(StartOfTokenColumn), NewlinesBefore(NewlinesBefore),
38 PreviousLinePostfix(PreviousLinePostfix),
39 CurrentLinePrefix(CurrentLinePrefix), IsAligned(IsAligned),
40 ContinuesPPDirective(ContinuesPPDirective), Spaces(Spaces),
41 IsInsideToken(IsInsideToken), IsTrailingComment(false), TokenLength(0),
42 PreviousEndOfTokenColumn(0), EscapedNewlineColumn(0),
43 StartOfBlockComment(nullptr), IndentationOffset(0), ConditionalsLevel(0) {
46 void WhitespaceManager::replaceWhitespace(FormatToken &Tok, unsigned Newlines,
48 unsigned StartOfTokenColumn,
49 bool IsAligned, bool InPPDirective) {
52 Tok.Decision = (Newlines > 0) ? FD_Break : FD_Continue;
53 Changes.push_back(Change(Tok, /*CreateReplacement=*/true, Tok.WhitespaceRange,
54 Spaces, StartOfTokenColumn, Newlines, "", "",
55 IsAligned, InPPDirective && !Tok.IsFirst,
56 /*IsInsideToken=*/false));
59 void WhitespaceManager::addUntouchableToken(const FormatToken &Tok,
63 Changes.push_back(Change(Tok, /*CreateReplacement=*/false,
64 Tok.WhitespaceRange, /*Spaces=*/0,
65 Tok.OriginalColumn, Tok.NewlinesBefore, "", "",
66 /*IsAligned=*/false, InPPDirective && !Tok.IsFirst,
67 /*IsInsideToken=*/false));
71 WhitespaceManager::addReplacement(const tooling::Replacement &Replacement) {
72 return Replaces.add(Replacement);
75 void WhitespaceManager::replaceWhitespaceInToken(
76 const FormatToken &Tok, unsigned Offset, unsigned ReplaceChars,
77 StringRef PreviousPostfix, StringRef CurrentPrefix, bool InPPDirective,
78 unsigned Newlines, int Spaces) {
81 SourceLocation Start = Tok.getStartOfNonWhitespace().getLocWithOffset(Offset);
83 Change(Tok, /*CreateReplacement=*/true,
84 SourceRange(Start, Start.getLocWithOffset(ReplaceChars)), Spaces,
85 std::max(0, Spaces), Newlines, PreviousPostfix, CurrentPrefix,
86 /*IsAligned=*/true, InPPDirective && !Tok.IsFirst,
87 /*IsInsideToken=*/true));
90 const tooling::Replacements &WhitespaceManager::generateReplacements() {
94 llvm::sort(Changes, Change::IsBeforeInFile(SourceMgr));
95 calculateLineBreakInformation();
96 alignConsecutiveMacros();
97 alignConsecutiveDeclarations();
98 alignConsecutiveBitFields();
99 alignConsecutiveAssignments();
100 alignChainedConditionals();
101 alignTrailingComments();
102 alignEscapedNewlines();
108 void WhitespaceManager::calculateLineBreakInformation() {
109 Changes[0].PreviousEndOfTokenColumn = 0;
110 Change *LastOutsideTokenChange = &Changes[0];
111 for (unsigned i = 1, e = Changes.size(); i != e; ++i) {
112 SourceLocation OriginalWhitespaceStart =
113 Changes[i].OriginalWhitespaceRange.getBegin();
114 SourceLocation PreviousOriginalWhitespaceEnd =
115 Changes[i - 1].OriginalWhitespaceRange.getEnd();
116 unsigned OriginalWhitespaceStartOffset =
117 SourceMgr.getFileOffset(OriginalWhitespaceStart);
118 unsigned PreviousOriginalWhitespaceEndOffset =
119 SourceMgr.getFileOffset(PreviousOriginalWhitespaceEnd);
120 assert(PreviousOriginalWhitespaceEndOffset <=
121 OriginalWhitespaceStartOffset);
122 const char *const PreviousOriginalWhitespaceEndData =
123 SourceMgr.getCharacterData(PreviousOriginalWhitespaceEnd);
124 StringRef Text(PreviousOriginalWhitespaceEndData,
125 SourceMgr.getCharacterData(OriginalWhitespaceStart) -
126 PreviousOriginalWhitespaceEndData);
127 // Usually consecutive changes would occur in consecutive tokens. This is
128 // not the case however when analyzing some preprocessor runs of the
129 // annotated lines. For example, in this code:
137 // one of the runs will produce the sequence of lines marked with line 1, 2
138 // and 3. So the two consecutive whitespace changes just before '// line 2'
139 // and before '#endif // line 3' span multiple lines and tokens:
141 // #else B{change X}[// line 2
143 // ]{change Y}#endif // line 3
145 // For this reason, if the text between consecutive changes spans multiple
146 // newlines, the token length must be adjusted to the end of the original
147 // line of the token.
148 auto NewlinePos = Text.find_first_of('\n');
149 if (NewlinePos == StringRef::npos) {
150 Changes[i - 1].TokenLength = OriginalWhitespaceStartOffset -
151 PreviousOriginalWhitespaceEndOffset +
152 Changes[i].PreviousLinePostfix.size() +
153 Changes[i - 1].CurrentLinePrefix.size();
155 Changes[i - 1].TokenLength =
156 NewlinePos + Changes[i - 1].CurrentLinePrefix.size();
159 // If there are multiple changes in this token, sum up all the changes until
160 // the end of the line.
161 if (Changes[i - 1].IsInsideToken && Changes[i - 1].NewlinesBefore == 0)
162 LastOutsideTokenChange->TokenLength +=
163 Changes[i - 1].TokenLength + Changes[i - 1].Spaces;
165 LastOutsideTokenChange = &Changes[i - 1];
167 Changes[i].PreviousEndOfTokenColumn =
168 Changes[i - 1].StartOfTokenColumn + Changes[i - 1].TokenLength;
170 Changes[i - 1].IsTrailingComment =
171 (Changes[i].NewlinesBefore > 0 || Changes[i].Tok->is(tok::eof) ||
172 (Changes[i].IsInsideToken && Changes[i].Tok->is(tok::comment))) &&
173 Changes[i - 1].Tok->is(tok::comment) &&
174 // FIXME: This is a dirty hack. The problem is that
175 // BreakableLineCommentSection does comment reflow changes and here is
176 // the aligning of trailing comments. Consider the case where we reflow
177 // the second line up in this example:
182 // That amounts to 2 changes by BreakableLineCommentSection:
183 // - the first, delimited by (), for the whitespace between the tokens,
184 // - and second, delimited by [], for the whitespace at the beginning
185 // of the second token:
190 // So in the end we have two changes like this:
192 // // line1()[ ]line 2
194 // Note that the OriginalWhitespaceStart of the second change is the
195 // same as the PreviousOriginalWhitespaceEnd of the first change.
196 // In this case, the below check ensures that the second change doesn't
197 // get treated as a trailing comment change here, since this might
198 // trigger additional whitespace to be wrongly inserted before "line 2"
199 // by the comment aligner here.
201 // For a proper solution we need a mechanism to say to WhitespaceManager
202 // that a particular change breaks the current sequence of trailing
204 OriginalWhitespaceStart != PreviousOriginalWhitespaceEnd;
206 // FIXME: The last token is currently not always an eof token; in those
207 // cases, setting TokenLength of the last token to 0 is wrong.
208 Changes.back().TokenLength = 0;
209 Changes.back().IsTrailingComment = Changes.back().Tok->is(tok::comment);
211 const WhitespaceManager::Change *LastBlockComment = nullptr;
212 for (auto &Change : Changes) {
213 // Reset the IsTrailingComment flag for changes inside of trailing comments
214 // so they don't get realigned later. Comment line breaks however still need
216 if (Change.IsInsideToken && Change.NewlinesBefore == 0)
217 Change.IsTrailingComment = false;
218 Change.StartOfBlockComment = nullptr;
219 Change.IndentationOffset = 0;
220 if (Change.Tok->is(tok::comment)) {
221 if (Change.Tok->is(TT_LineComment) || !Change.IsInsideToken)
222 LastBlockComment = &Change;
224 if ((Change.StartOfBlockComment = LastBlockComment))
225 Change.IndentationOffset =
226 Change.StartOfTokenColumn -
227 Change.StartOfBlockComment->StartOfTokenColumn;
230 LastBlockComment = nullptr;
234 // Compute conditional nesting level
235 // Level is increased for each conditional, unless this conditional continues
236 // a chain of conditional, i.e. starts immediately after the colon of another
238 SmallVector<bool, 16> ScopeStack;
239 int ConditionalsLevel = 0;
240 for (auto &Change : Changes) {
241 for (unsigned i = 0, e = Change.Tok->FakeLParens.size(); i != e; ++i) {
242 bool isNestedConditional =
243 Change.Tok->FakeLParens[e - 1 - i] == prec::Conditional &&
244 !(i == 0 && Change.Tok->Previous &&
245 Change.Tok->Previous->is(TT_ConditionalExpr) &&
246 Change.Tok->Previous->is(tok::colon));
247 if (isNestedConditional)
249 ScopeStack.push_back(isNestedConditional);
252 Change.ConditionalsLevel = ConditionalsLevel;
254 for (unsigned i = Change.Tok->FakeRParens; i > 0 && ScopeStack.size();
256 if (ScopeStack.pop_back_val())
262 // Align a single sequence of tokens, see AlignTokens below.
263 template <typename F>
265 AlignTokenSequence(unsigned Start, unsigned End, unsigned Column, F &&Matches,
266 SmallVector<WhitespaceManager::Change, 16> &Changes) {
267 bool FoundMatchOnLine = false;
270 // ScopeStack keeps track of the current scope depth. It contains indices of
271 // the first token on each scope.
272 // We only run the "Matches" function on tokens from the outer-most scope.
273 // However, we do need to pay special attention to one class of tokens
274 // that are not in the outer-most scope, and that is function parameters
275 // which are split across multiple lines, as illustrated by this example:
279 // In the above example, we need to take special care to ensure that
280 // 'double z' is indented along with it's owning function 'b'.
281 // Special handling is required for 'nested' ternary operators.
282 SmallVector<unsigned, 16> ScopeStack;
284 for (unsigned i = Start; i != End; ++i) {
285 if (ScopeStack.size() != 0 &&
286 Changes[i].indentAndNestingLevel() <
287 Changes[ScopeStack.back()].indentAndNestingLevel())
288 ScopeStack.pop_back();
290 // Compare current token to previous non-comment token to ensure whether
291 // it is in a deeper scope or not.
292 unsigned PreviousNonComment = i - 1;
293 while (PreviousNonComment > Start &&
294 Changes[PreviousNonComment].Tok->is(tok::comment))
295 PreviousNonComment--;
296 if (i != Start && Changes[i].indentAndNestingLevel() >
297 Changes[PreviousNonComment].indentAndNestingLevel())
298 ScopeStack.push_back(i);
300 bool InsideNestedScope = ScopeStack.size() != 0;
302 if (Changes[i].NewlinesBefore > 0 && !InsideNestedScope) {
304 FoundMatchOnLine = false;
307 // If this is the first matching token to be aligned, remember by how many
308 // spaces it has to be shifted, so the rest of the changes on the line are
309 // shifted by the same amount
310 if (!FoundMatchOnLine && !InsideNestedScope && Matches(Changes[i])) {
311 FoundMatchOnLine = true;
312 Shift = Column - Changes[i].StartOfTokenColumn;
313 Changes[i].Spaces += Shift;
316 // This is for function parameters that are split across multiple lines,
317 // as mentioned in the ScopeStack comment.
318 if (InsideNestedScope && Changes[i].NewlinesBefore > 0) {
319 unsigned ScopeStart = ScopeStack.back();
320 if (Changes[ScopeStart - 1].Tok->is(TT_FunctionDeclarationName) ||
321 (ScopeStart > Start + 1 &&
322 Changes[ScopeStart - 2].Tok->is(TT_FunctionDeclarationName)) ||
323 Changes[i].Tok->is(TT_ConditionalExpr) ||
324 (Changes[i].Tok->Previous &&
325 Changes[i].Tok->Previous->is(TT_ConditionalExpr)))
326 Changes[i].Spaces += Shift;
330 Changes[i].StartOfTokenColumn += Shift;
331 if (i + 1 != Changes.size())
332 Changes[i + 1].PreviousEndOfTokenColumn += Shift;
336 // Walk through a subset of the changes, starting at StartAt, and find
337 // sequences of matching tokens to align. To do so, keep track of the lines and
338 // whether or not a matching token was found on a line. If a matching token is
339 // found, extend the current sequence. If the current line cannot be part of a
340 // sequence, e.g. because there is an empty line before it or it contains only
341 // non-matching tokens, finalize the previous sequence.
342 // The value returned is the token on which we stopped, either because we
343 // exhausted all items inside Changes, or because we hit a scope level higher
344 // than our initial scope.
345 // This function is recursive. Each invocation processes only the scope level
346 // equal to the initial level, which is the level of Changes[StartAt].
347 // If we encounter a scope level greater than the initial level, then we call
348 // ourselves recursively, thereby avoiding the pollution of the current state
349 // with the alignment requirements of the nested sub-level. This recursive
350 // behavior is necessary for aligning function prototypes that have one or more
352 // If this function encounters a scope level less than the initial level,
353 // it returns the current position.
354 // There is a non-obvious subtlety in the recursive behavior: Even though we
355 // defer processing of nested levels to recursive invocations of this
356 // function, when it comes time to align a sequence of tokens, we run the
357 // alignment on the entire sequence, including the nested levels.
358 // When doing so, most of the nested tokens are skipped, because their
359 // alignment was already handled by the recursive invocations of this function.
360 // However, the special exception is that we do NOT skip function parameters
361 // that are split across multiple lines. See the test case in FormatTest.cpp
362 // that mentions "split function parameter alignment" for an example of this.
363 template <typename F>
364 static unsigned AlignTokens(const FormatStyle &Style, F &&Matches,
365 SmallVector<WhitespaceManager::Change, 16> &Changes,
367 unsigned MinColumn = 0;
368 unsigned MaxColumn = UINT_MAX;
370 // Line number of the start and the end of the current token sequence.
371 unsigned StartOfSequence = 0;
372 unsigned EndOfSequence = 0;
374 // Measure the scope level (i.e. depth of (), [], {}) of the first token, and
375 // abort when we hit any token in a higher scope than the starting one.
376 auto IndentAndNestingLevel = StartAt < Changes.size()
377 ? Changes[StartAt].indentAndNestingLevel()
378 : std::tuple<unsigned, unsigned, unsigned>();
380 // Keep track of the number of commas before the matching tokens, we will only
381 // align a sequence of matching tokens if they are preceded by the same number
383 unsigned CommasBeforeLastMatch = 0;
384 unsigned CommasBeforeMatch = 0;
386 // Whether a matching token has been found on the current line.
387 bool FoundMatchOnLine = false;
389 // Aligns a sequence of matching tokens, on the MinColumn column.
391 // Sequences start from the first matching token to align, and end at the
392 // first token of the first line that doesn't need to be aligned.
394 // We need to adjust the StartOfTokenColumn of each Change that is on a line
395 // containing any matching token to be aligned and located after such token.
396 auto AlignCurrentSequence = [&] {
397 if (StartOfSequence > 0 && StartOfSequence < EndOfSequence)
398 AlignTokenSequence(StartOfSequence, EndOfSequence, MinColumn, Matches,
401 MaxColumn = UINT_MAX;
406 unsigned i = StartAt;
407 for (unsigned e = Changes.size(); i != e; ++i) {
408 if (Changes[i].indentAndNestingLevel() < IndentAndNestingLevel)
411 if (Changes[i].NewlinesBefore != 0) {
412 CommasBeforeMatch = 0;
414 // If there is a blank line, or if the last line didn't contain any
415 // matching token, the sequence ends here.
416 if (Changes[i].NewlinesBefore > 1 || !FoundMatchOnLine)
417 AlignCurrentSequence();
419 FoundMatchOnLine = false;
422 if (Changes[i].Tok->is(tok::comma)) {
424 } else if (Changes[i].indentAndNestingLevel() > IndentAndNestingLevel) {
425 // Call AlignTokens recursively, skipping over this scope block.
426 unsigned StoppedAt = AlignTokens(Style, Matches, Changes, i);
431 if (!Matches(Changes[i]))
434 // If there is more than one matching token per line, or if the number of
435 // preceding commas, do not match anymore, end the sequence.
436 if (FoundMatchOnLine || CommasBeforeMatch != CommasBeforeLastMatch)
437 AlignCurrentSequence();
439 CommasBeforeLastMatch = CommasBeforeMatch;
440 FoundMatchOnLine = true;
442 if (StartOfSequence == 0)
445 unsigned ChangeMinColumn = Changes[i].StartOfTokenColumn;
446 int LineLengthAfter = Changes[i].TokenLength;
447 for (unsigned j = i + 1; j != e && Changes[j].NewlinesBefore == 0; ++j) {
448 LineLengthAfter += Changes[j].Spaces;
449 // Changes are generally 1:1 with the tokens, but a change could also be
450 // inside of a token, in which case it's counted more than once: once for
451 // the whitespace surrounding the token (!IsInsideToken) and once for
452 // each whitespace change within it (IsInsideToken).
453 // Therefore, changes inside of a token should only count the space.
454 if (!Changes[j].IsInsideToken)
455 LineLengthAfter += Changes[j].TokenLength;
457 unsigned ChangeMaxColumn = Style.ColumnLimit - LineLengthAfter;
459 // If we are restricted by the maximum column width, end the sequence.
460 if (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn ||
461 CommasBeforeLastMatch != CommasBeforeMatch) {
462 AlignCurrentSequence();
466 MinColumn = std::max(MinColumn, ChangeMinColumn);
467 MaxColumn = std::min(MaxColumn, ChangeMaxColumn);
471 AlignCurrentSequence();
475 // Aligns a sequence of matching tokens, on the MinColumn column.
477 // Sequences start from the first matching token to align, and end at the
478 // first token of the first line that doesn't need to be aligned.
480 // We need to adjust the StartOfTokenColumn of each Change that is on a line
481 // containing any matching token to be aligned and located after such token.
482 static void AlignMacroSequence(
483 unsigned &StartOfSequence, unsigned &EndOfSequence, unsigned &MinColumn,
484 unsigned &MaxColumn, bool &FoundMatchOnLine,
485 std::function<bool(const WhitespaceManager::Change &C)> AlignMacrosMatches,
486 SmallVector<WhitespaceManager::Change, 16> &Changes) {
487 if (StartOfSequence > 0 && StartOfSequence < EndOfSequence) {
489 FoundMatchOnLine = false;
492 for (unsigned I = StartOfSequence; I != EndOfSequence; ++I) {
493 if (Changes[I].NewlinesBefore > 0) {
495 FoundMatchOnLine = false;
498 // If this is the first matching token to be aligned, remember by how many
499 // spaces it has to be shifted, so the rest of the changes on the line are
500 // shifted by the same amount
501 if (!FoundMatchOnLine && AlignMacrosMatches(Changes[I])) {
502 FoundMatchOnLine = true;
503 Shift = MinColumn - Changes[I].StartOfTokenColumn;
504 Changes[I].Spaces += Shift;
508 Changes[I].StartOfTokenColumn += Shift;
509 if (I + 1 != Changes.size())
510 Changes[I + 1].PreviousEndOfTokenColumn += Shift;
515 MaxColumn = UINT_MAX;
520 void WhitespaceManager::alignConsecutiveMacros() {
521 if (!Style.AlignConsecutiveMacros)
524 auto AlignMacrosMatches = [](const Change &C) {
525 const FormatToken *Current = C.Tok;
526 unsigned SpacesRequiredBefore = 1;
528 if (Current->SpacesRequiredBefore == 0 || !Current->Previous)
531 Current = Current->Previous;
533 // If token is a ")", skip over the parameter list, to the
534 // token that precedes the "("
535 if (Current->is(tok::r_paren) && Current->MatchingParen) {
536 Current = Current->MatchingParen->Previous;
537 SpacesRequiredBefore = 0;
540 if (!Current || !Current->is(tok::identifier))
543 if (!Current->Previous || !Current->Previous->is(tok::pp_define))
546 // For a macro function, 0 spaces are required between the
547 // identifier and the lparen that opens the parameter list.
548 // For a simple macro, 1 space is required between the
549 // identifier and the first token of the defined value.
550 return Current->Next->SpacesRequiredBefore == SpacesRequiredBefore;
553 unsigned MinColumn = 0;
554 unsigned MaxColumn = UINT_MAX;
556 // Start and end of the token sequence we're processing.
557 unsigned StartOfSequence = 0;
558 unsigned EndOfSequence = 0;
560 // Whether a matching token has been found on the current line.
561 bool FoundMatchOnLine = false;
564 for (unsigned E = Changes.size(); I != E; ++I) {
565 if (Changes[I].NewlinesBefore != 0) {
567 // If there is a blank line, or if the last line didn't contain any
568 // matching token, the sequence ends here.
569 if (Changes[I].NewlinesBefore > 1 || !FoundMatchOnLine)
570 AlignMacroSequence(StartOfSequence, EndOfSequence, MinColumn, MaxColumn,
571 FoundMatchOnLine, AlignMacrosMatches, Changes);
573 FoundMatchOnLine = false;
576 if (!AlignMacrosMatches(Changes[I]))
579 FoundMatchOnLine = true;
581 if (StartOfSequence == 0)
584 unsigned ChangeMinColumn = Changes[I].StartOfTokenColumn;
585 int LineLengthAfter = -Changes[I].Spaces;
586 for (unsigned j = I; j != E && Changes[j].NewlinesBefore == 0; ++j)
587 LineLengthAfter += Changes[j].Spaces + Changes[j].TokenLength;
588 unsigned ChangeMaxColumn = Style.ColumnLimit - LineLengthAfter;
590 MinColumn = std::max(MinColumn, ChangeMinColumn);
591 MaxColumn = std::min(MaxColumn, ChangeMaxColumn);
595 AlignMacroSequence(StartOfSequence, EndOfSequence, MinColumn, MaxColumn,
596 FoundMatchOnLine, AlignMacrosMatches, Changes);
599 void WhitespaceManager::alignConsecutiveAssignments() {
600 if (!Style.AlignConsecutiveAssignments)
605 [&](const Change &C) {
606 // Do not align on equal signs that are first on a line.
607 if (C.NewlinesBefore > 0)
610 // Do not align on equal signs that are last on a line.
611 if (&C != &Changes.back() && (&C + 1)->NewlinesBefore > 0)
614 return C.Tok->is(tok::equal);
616 Changes, /*StartAt=*/0);
619 void WhitespaceManager::alignConsecutiveBitFields() {
620 if (!Style.AlignConsecutiveBitFields)
625 [&](Change const &C) {
626 // Do not align on ':' that is first on a line.
627 if (C.NewlinesBefore > 0)
630 // Do not align on ':' that is last on a line.
631 if (&C != &Changes.back() && (&C + 1)->NewlinesBefore > 0)
634 return C.Tok->is(TT_BitFieldColon);
636 Changes, /*StartAt=*/0);
639 void WhitespaceManager::alignConsecutiveDeclarations() {
640 if (!Style.AlignConsecutiveDeclarations)
643 // FIXME: Currently we don't handle properly the PointerAlignment: Right
644 // The * and & are not aligned and are left dangling. Something has to be done
645 // about it, but it raises the question of alignment of code like:
646 // const char* const* v1;
648 // SomeVeryLongType const& v3;
651 [](Change const &C) {
652 // tok::kw_operator is necessary for aligning operator overload
654 if (C.Tok->isOneOf(TT_FunctionDeclarationName, tok::kw_operator))
656 if (C.Tok->isNot(TT_StartOfName))
658 // Check if there is a subsequent name that starts the same declaration.
659 for (FormatToken *Next = C.Tok->Next; Next; Next = Next->Next) {
660 if (Next->is(tok::comment))
662 if (!Next->Tok.getIdentifierInfo())
664 if (Next->isOneOf(TT_StartOfName, TT_FunctionDeclarationName,
670 Changes, /*StartAt=*/0);
673 void WhitespaceManager::alignChainedConditionals() {
674 if (Style.BreakBeforeTernaryOperators) {
677 [](Change const &C) {
678 // Align question operators and last colon
679 return C.Tok->is(TT_ConditionalExpr) &&
680 ((C.Tok->is(tok::question) && !C.NewlinesBefore) ||
681 (C.Tok->is(tok::colon) && C.Tok->Next &&
682 (C.Tok->Next->FakeLParens.size() == 0 ||
683 C.Tok->Next->FakeLParens.back() != prec::Conditional)));
685 Changes, /*StartAt=*/0);
687 static auto AlignWrappedOperand = [](Change const &C) {
688 auto Previous = C.Tok->getPreviousNonComment(); // Previous;
689 return C.NewlinesBefore && Previous && Previous->is(TT_ConditionalExpr) &&
690 (Previous->is(tok::question) ||
691 (Previous->is(tok::colon) &&
692 (C.Tok->FakeLParens.size() == 0 ||
693 C.Tok->FakeLParens.back() != prec::Conditional)));
695 // Ensure we keep alignment of wrapped operands with non-wrapped operands
696 // Since we actually align the operators, the wrapped operands need the
697 // extra offset to be properly aligned.
698 for (Change &C : Changes) {
699 if (AlignWrappedOperand(C))
700 C.StartOfTokenColumn -= 2;
704 [this](Change const &C) {
705 // Align question operators if next operand is not wrapped, as
706 // well as wrapped operands after question operator or last
707 // colon in conditional sequence
708 return (C.Tok->is(TT_ConditionalExpr) && C.Tok->is(tok::question) &&
709 &C != &Changes.back() && (&C + 1)->NewlinesBefore == 0 &&
710 !(&C + 1)->IsTrailingComment) ||
711 AlignWrappedOperand(C);
713 Changes, /*StartAt=*/0);
717 void WhitespaceManager::alignTrailingComments() {
718 unsigned MinColumn = 0;
719 unsigned MaxColumn = UINT_MAX;
720 unsigned StartOfSequence = 0;
721 bool BreakBeforeNext = false;
722 unsigned Newlines = 0;
723 for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
724 if (Changes[i].StartOfBlockComment)
726 Newlines += Changes[i].NewlinesBefore;
727 if (!Changes[i].IsTrailingComment)
730 unsigned ChangeMinColumn = Changes[i].StartOfTokenColumn;
731 unsigned ChangeMaxColumn;
733 if (Style.ColumnLimit == 0)
734 ChangeMaxColumn = UINT_MAX;
735 else if (Style.ColumnLimit >= Changes[i].TokenLength)
736 ChangeMaxColumn = Style.ColumnLimit - Changes[i].TokenLength;
738 ChangeMaxColumn = ChangeMinColumn;
740 // If we don't create a replacement for this change, we have to consider
741 // it to be immovable.
742 if (!Changes[i].CreateReplacement)
743 ChangeMaxColumn = ChangeMinColumn;
745 if (i + 1 != e && Changes[i + 1].ContinuesPPDirective)
746 ChangeMaxColumn -= 2;
747 // If this comment follows an } in column 0, it probably documents the
748 // closing of a namespace and we don't want to align it.
749 bool FollowsRBraceInColumn0 = i > 0 && Changes[i].NewlinesBefore == 0 &&
750 Changes[i - 1].Tok->is(tok::r_brace) &&
751 Changes[i - 1].StartOfTokenColumn == 0;
752 bool WasAlignedWithStartOfNextLine = false;
753 if (Changes[i].NewlinesBefore == 1) { // A comment on its own line.
754 unsigned CommentColumn = SourceMgr.getSpellingColumnNumber(
755 Changes[i].OriginalWhitespaceRange.getEnd());
756 for (unsigned j = i + 1; j != e; ++j) {
757 if (Changes[j].Tok->is(tok::comment))
760 unsigned NextColumn = SourceMgr.getSpellingColumnNumber(
761 Changes[j].OriginalWhitespaceRange.getEnd());
762 // The start of the next token was previously aligned with the
763 // start of this comment.
764 WasAlignedWithStartOfNextLine =
765 CommentColumn == NextColumn ||
766 CommentColumn == NextColumn + Style.IndentWidth;
770 if (!Style.AlignTrailingComments || FollowsRBraceInColumn0) {
771 alignTrailingComments(StartOfSequence, i, MinColumn);
772 MinColumn = ChangeMinColumn;
773 MaxColumn = ChangeMinColumn;
775 } else if (BreakBeforeNext || Newlines > 1 ||
776 (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn) ||
777 // Break the comment sequence if the previous line did not end
778 // in a trailing comment.
779 (Changes[i].NewlinesBefore == 1 && i > 0 &&
780 !Changes[i - 1].IsTrailingComment) ||
781 WasAlignedWithStartOfNextLine) {
782 alignTrailingComments(StartOfSequence, i, MinColumn);
783 MinColumn = ChangeMinColumn;
784 MaxColumn = ChangeMaxColumn;
787 MinColumn = std::max(MinColumn, ChangeMinColumn);
788 MaxColumn = std::min(MaxColumn, ChangeMaxColumn);
790 BreakBeforeNext = (i == 0) || (Changes[i].NewlinesBefore > 1) ||
791 // Never start a sequence with a comment at the beginning
793 (Changes[i].NewlinesBefore == 1 && StartOfSequence == i);
796 alignTrailingComments(StartOfSequence, Changes.size(), MinColumn);
799 void WhitespaceManager::alignTrailingComments(unsigned Start, unsigned End,
801 for (unsigned i = Start; i != End; ++i) {
803 if (Changes[i].IsTrailingComment) {
804 Shift = Column - Changes[i].StartOfTokenColumn;
806 if (Changes[i].StartOfBlockComment) {
807 Shift = Changes[i].IndentationOffset +
808 Changes[i].StartOfBlockComment->StartOfTokenColumn -
809 Changes[i].StartOfTokenColumn;
812 Changes[i].Spaces += Shift;
813 if (i + 1 != Changes.size())
814 Changes[i + 1].PreviousEndOfTokenColumn += Shift;
815 Changes[i].StartOfTokenColumn += Shift;
819 void WhitespaceManager::alignEscapedNewlines() {
820 if (Style.AlignEscapedNewlines == FormatStyle::ENAS_DontAlign)
823 bool AlignLeft = Style.AlignEscapedNewlines == FormatStyle::ENAS_Left;
824 unsigned MaxEndOfLine = AlignLeft ? 0 : Style.ColumnLimit;
825 unsigned StartOfMacro = 0;
826 for (unsigned i = 1, e = Changes.size(); i < e; ++i) {
827 Change &C = Changes[i];
828 if (C.NewlinesBefore > 0) {
829 if (C.ContinuesPPDirective) {
830 MaxEndOfLine = std::max(C.PreviousEndOfTokenColumn + 2, MaxEndOfLine);
832 alignEscapedNewlines(StartOfMacro + 1, i, MaxEndOfLine);
833 MaxEndOfLine = AlignLeft ? 0 : Style.ColumnLimit;
838 alignEscapedNewlines(StartOfMacro + 1, Changes.size(), MaxEndOfLine);
841 void WhitespaceManager::alignEscapedNewlines(unsigned Start, unsigned End,
843 for (unsigned i = Start; i < End; ++i) {
844 Change &C = Changes[i];
845 if (C.NewlinesBefore > 0) {
846 assert(C.ContinuesPPDirective);
847 if (C.PreviousEndOfTokenColumn + 1 > Column)
848 C.EscapedNewlineColumn = 0;
850 C.EscapedNewlineColumn = Column;
855 void WhitespaceManager::generateChanges() {
856 for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
857 const Change &C = Changes[i];
859 assert(Changes[i - 1].OriginalWhitespaceRange.getBegin() !=
860 C.OriginalWhitespaceRange.getBegin() &&
861 "Generating two replacements for the same location");
863 if (C.CreateReplacement) {
864 std::string ReplacementText = C.PreviousLinePostfix;
865 if (C.ContinuesPPDirective)
866 appendEscapedNewlineText(ReplacementText, C.NewlinesBefore,
867 C.PreviousEndOfTokenColumn,
868 C.EscapedNewlineColumn);
870 appendNewlineText(ReplacementText, C.NewlinesBefore);
872 ReplacementText, C.Tok->IndentLevel, std::max(0, C.Spaces),
873 C.StartOfTokenColumn - std::max(0, C.Spaces), C.IsAligned);
874 ReplacementText.append(C.CurrentLinePrefix);
875 storeReplacement(C.OriginalWhitespaceRange, ReplacementText);
880 void WhitespaceManager::storeReplacement(SourceRange Range, StringRef Text) {
881 unsigned WhitespaceLength = SourceMgr.getFileOffset(Range.getEnd()) -
882 SourceMgr.getFileOffset(Range.getBegin());
883 // Don't create a replacement, if it does not change anything.
884 if (StringRef(SourceMgr.getCharacterData(Range.getBegin()),
885 WhitespaceLength) == Text)
887 auto Err = Replaces.add(tooling::Replacement(
888 SourceMgr, CharSourceRange::getCharRange(Range), Text));
889 // FIXME: better error handling. For now, just print an error message in the
892 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
897 void WhitespaceManager::appendNewlineText(std::string &Text,
899 for (unsigned i = 0; i < Newlines; ++i)
900 Text.append(UseCRLF ? "\r\n" : "\n");
903 void WhitespaceManager::appendEscapedNewlineText(
904 std::string &Text, unsigned Newlines, unsigned PreviousEndOfTokenColumn,
905 unsigned EscapedNewlineColumn) {
908 std::max<int>(1, EscapedNewlineColumn - PreviousEndOfTokenColumn - 1);
909 for (unsigned i = 0; i < Newlines; ++i) {
910 Text.append(Spaces, ' ');
911 Text.append(UseCRLF ? "\\\r\n" : "\\\n");
912 Spaces = std::max<int>(0, EscapedNewlineColumn - 1);
917 void WhitespaceManager::appendIndentText(std::string &Text,
918 unsigned IndentLevel, unsigned Spaces,
919 unsigned WhitespaceStartColumn,
921 switch (Style.UseTab) {
922 case FormatStyle::UT_Never:
923 Text.append(Spaces, ' ');
925 case FormatStyle::UT_Always: {
926 if (Style.TabWidth) {
927 unsigned FirstTabWidth =
928 Style.TabWidth - WhitespaceStartColumn % Style.TabWidth;
930 // Insert only spaces when we want to end up before the next tab.
931 if (Spaces < FirstTabWidth || Spaces == 1) {
932 Text.append(Spaces, ' ');
935 // Align to the next tab.
936 Spaces -= FirstTabWidth;
939 Text.append(Spaces / Style.TabWidth, '\t');
940 Text.append(Spaces % Style.TabWidth, ' ');
941 } else if (Spaces == 1) {
942 Text.append(Spaces, ' ');
946 case FormatStyle::UT_ForIndentation:
947 if (WhitespaceStartColumn == 0) {
948 unsigned Indentation = IndentLevel * Style.IndentWidth;
949 Spaces = appendTabIndent(Text, Spaces, Indentation);
951 Text.append(Spaces, ' ');
953 case FormatStyle::UT_ForContinuationAndIndentation:
954 if (WhitespaceStartColumn == 0)
955 Spaces = appendTabIndent(Text, Spaces, Spaces);
956 Text.append(Spaces, ' ');
958 case FormatStyle::UT_AlignWithSpaces:
959 if (WhitespaceStartColumn == 0) {
960 unsigned Indentation =
961 IsAligned ? IndentLevel * Style.IndentWidth : Spaces;
962 Spaces = appendTabIndent(Text, Spaces, Indentation);
964 Text.append(Spaces, ' ');
969 unsigned WhitespaceManager::appendTabIndent(std::string &Text, unsigned Spaces,
970 unsigned Indentation) {
971 // This happens, e.g. when a line in a block comment is indented less than the
973 if (Indentation > Spaces)
974 Indentation = Spaces;
975 if (Style.TabWidth) {
976 unsigned Tabs = Indentation / Style.TabWidth;
977 Text.append(Tabs, '\t');
978 Spaces -= Tabs * Style.TabWidth;
983 } // namespace format