15#include "llvm/ADT/STLExtras.h"
16#include "llvm/ADT/SmallVector.h"
34 return C.Tok->IndentLevel;
44 return SourceMgr.isBeforeInTranslationUnit(
49 SourceMgr.isBeforeInTranslationUnit(
75 unsigned StartOfTokenColumn,
const FormatToken *AlignedTo,
76 bool InPPDirective,
unsigned IndentedFromColumn,
bool CreateReplacement) {
79 if (CreateReplacement)
81 Changes.push_back(
Change(
Tok, CreateReplacement,
Tok.WhitespaceRange, Spaces,
82 StartOfTokenColumn, IndentedFromColumn,
Newlines,
"",
83 "", AlignedTo, InPPDirective && !
Tok.IsFirst,
92 Tok,
false,
Tok.WhitespaceRange, 0,
93 Tok.OriginalColumn, 0,
Tok.NewlinesBefore,
"",
"",
94 nullptr, InPPDirective && !
Tok.IsFirst,
100 return Replaces.add(Replacement);
104 size_t LF =
Text.count(
'\n');
105 size_t CR =
Text.count(
'\r') * 2;
106 return LF == CR ? DefaultToCRLF : CR > LF;
111 StringRef PreviousPostfix, StringRef CurrentPrefix,
bool InPPDirective,
120 PreviousPostfix, CurrentPrefix,
121 &
Tok, InPPDirective && !
Tok.IsFirst,
130 calculateLineBreakInformation();
131 alignConsecutiveMacros();
132 alignConsecutiveShortCaseStatements(
true);
133 alignConsecutiveShortCaseStatements(
false);
134 alignConsecutiveDeclarations();
135 alignConsecutiveBitFields();
136 alignConsecutiveAssignments();
137 if (Style.isTableGen()) {
138 alignConsecutiveTableGenBreakingDAGArgColons();
139 alignConsecutiveTableGenCondOperatorColons();
140 alignConsecutiveTableGenDefinitions();
142 alignChainedConditionals();
143 alignTrailingComments();
144 alignEscapedNewlines();
145 alignArrayInitializers();
151void WhitespaceManager::calculateLineBreakInformation() {
152 Changes[0].PreviousEndOfTokenColumn = 0;
153 Change *LastOutsideTokenChange = &Changes[0];
154 for (
unsigned I = 1, e = Changes.size(); I != e; ++I) {
155 auto &
C = Changes[I];
156 auto &P = Changes[I - 1];
157 auto &PrevTokLength = P.TokenLength;
158 const auto *PP = I > 1 ? &Changes[I - 2] :
nullptr;
160 C.OriginalWhitespaceRange.getBegin();
162 P.OriginalWhitespaceRange.getEnd();
163 unsigned OriginalWhitespaceStartOffset =
164 SourceMgr.getFileOffset(OriginalWhitespaceStart);
165 unsigned PreviousOriginalWhitespaceEndOffset =
166 SourceMgr.getFileOffset(PreviousOriginalWhitespaceEnd);
167 assert(PreviousOriginalWhitespaceEndOffset <=
168 OriginalWhitespaceStartOffset);
169 const char *
const PreviousOriginalWhitespaceEndData =
170 SourceMgr.getCharacterData(PreviousOriginalWhitespaceEnd);
171 StringRef
Text(PreviousOriginalWhitespaceEndData,
172 SourceMgr.getCharacterData(OriginalWhitespaceStart) -
173 PreviousOriginalWhitespaceEndData);
195 auto NewlinePos =
Text.find_first_of(
'\n');
196 if (NewlinePos == StringRef::npos) {
197 PrevTokLength = OriginalWhitespaceStartOffset -
198 PreviousOriginalWhitespaceEndOffset +
199 C.PreviousLinePostfix.size() + P.CurrentLinePrefix.size();
200 if (!P.IsInsideToken)
201 PrevTokLength = std::min(PrevTokLength, P.Tok->ColumnWidth);
203 PrevTokLength = NewlinePos + P.CurrentLinePrefix.size();
208 if (P.IsInsideToken && P.NewlinesBefore == 0)
209 LastOutsideTokenChange->TokenLength += PrevTokLength + P.Spaces;
211 LastOutsideTokenChange = &P;
213 C.PreviousEndOfTokenColumn = P.StartOfTokenColumn + PrevTokLength;
215 P.IsTrailingComment =
216 (
C.NewlinesBefore > 0 ||
C.Tok->is(tok::eof) ||
217 (
C.IsInsideToken &&
C.Tok->is(tok::comment))) &&
218 P.Tok->is(tok::comment) &&
219 (P.NewlinesBefore == 0 || !PP || PP->IsTrailingComment) &&
250 OriginalWhitespaceStart != PreviousOriginalWhitespaceEnd;
254 Changes.back().TokenLength = 0;
255 Changes.back().IsTrailingComment = Changes.back().Tok->is(tok::comment);
257 const WhitespaceManager::Change *LastBlockComment =
nullptr;
258 for (
auto &
Change : Changes) {
268 LastBlockComment = &
Change;
275 LastBlockComment =
nullptr;
283 SmallVector<bool, 16> ScopeStack;
284 int ConditionalsLevel = 0;
285 for (
auto &
Change : Changes) {
287 bool isNestedConditional =
292 if (isNestedConditional)
294 ScopeStack.push_back(isNestedConditional);
300 if (ScopeStack.pop_back_val())
311 auto &FirstChange = Changes[Start];
312 const int ColumnChange = Spaces - FirstChange.Spaces;
314 if (ColumnChange == 0)
317 FirstChange.Spaces += ColumnChange;
318 FirstChange.StartOfTokenColumn += ColumnChange;
320 for (
auto I = Start + 1; I < Changes.size(); I++) {
321 auto &Change = Changes[I];
323 Change.PreviousEndOfTokenColumn += ColumnChange;
325 if (Change.NewlinesBefore > 0)
328 Change.StartOfTokenColumn += ColumnChange;
338 assert(Delta > 0 || (
abs(Delta) <= Changes[Start].Spaces));
348 unsigned Column,
bool RightJustify,
351 unsigned OriginalMatchColumn = 0;
379 for (
unsigned i = Start; i != End; ++i) {
380 auto &CurrentChange = Changes[i];
381 if (!Matches.empty() && Matches[0] < i)
382 Matches.consume_front();
383 assert(Matches.empty() || Matches[0] >= i);
384 while (!ScopeStack.empty() &&
385 CurrentChange.indentAndNestingLevel() < ScopeStack.back()) {
386 ScopeStack.pop_back();
390 if (ScopeStack.size() == 1u && CurrentChange.NewlinesBefore != 0u &&
391 CurrentChange.indentAndNestingLevel() > ScopeStack[0] &&
392 CurrentChange.IndentedFromColumn < OriginalMatchColumn) {
393 ScopeStack.push_back(CurrentChange.indentAndNestingLevel());
396 bool InsideNestedScope =
397 !ScopeStack.empty() &&
398 (CurrentChange.indentAndNestingLevel() > ScopeStack[0] ||
399 (CurrentChange.indentAndNestingLevel() == ScopeStack[0] &&
400 CurrentChange.IndentedFromColumn >= OriginalMatchColumn));
402 if (CurrentChange.NewlinesBefore > 0 && !InsideNestedScope)
408 if (!Matches.empty() && Matches[0] == i) {
409 OriginalMatchColumn = CurrentChange.StartOfTokenColumn;
410 Shift =
Column - (RightJustify ? CurrentChange.TokenLength : 0) -
411 CurrentChange.StartOfTokenColumn;
412 ScopeStack = {CurrentChange.indentAndNestingLevel()};
421 if ((!Matches.empty() && Matches[0] == i) ||
422 (ScopeStack.size() == 1u && CurrentChange.NewlinesBefore > 0 &&
423 InsideNestedScope)) {
424 CurrentChange.IndentedFromColumn += Shift;
430 CurrentChange.Spaces >=
431 static_cast<int>(Changes[i].Tok->SpacesRequiredBefore) ||
432 CurrentChange.Tok->is(tok::eof));
438 CurrentChange.Spaces != 0 &&
439 CurrentChange.Tok->isNoneOf(tok::equal, tok::r_paren,
440 TT_TemplateCloser)) {
441 const bool ReferenceNotRightAligned =
447 assert(Changes[
Previous].
Tok->isPointerOrReference());
449 if (ReferenceNotRightAligned)
463enum class AlignStrategy {
Normal,
Macro, CaseBody, CaseColon };
506template <
typename F, AlignStrategy Strategy = AlignStrategy::Normal>
511 bool RightJustify =
false) {
522 unsigned WidthLeft = 0;
525 unsigned WidthAnchor = 0;
528 unsigned WidthRight = 0;
531 unsigned StartOfSequence = 0;
532 unsigned EndOfSequence = 0;
539 const auto IndentAndNestingLevel =
540 StartAt < Changes.size() ? Changes[StartAt].indentAndNestingLevel()
541 : std::tuple<unsigned, unsigned, unsigned>();
546 unsigned CommasBeforeLastMatch = 0;
547 unsigned CommasBeforeMatch = 0;
550 std::optional<unsigned> MatchingColumn;
553 bool LineIsComment =
true;
562 auto AlignCurrentSequence = [&] {
563 if (StartOfSequence > 0 && StartOfSequence < EndOfSequence) {
565 WidthLeft + WidthAnchor, RightJustify, MatchedIndices,
573 MatchedIndices.clear();
576 unsigned I = StartAt;
577 const auto E = Changes.size();
578 for (
const auto LoopEnd = Strategy == AlignStrategy::CaseBody ? E - 1 : E;
580 auto &CurrentChange = Changes[I];
581 if (CurrentChange.indentAndNestingLevel() < IndentAndNestingLevel)
584 if (CurrentChange.NewlinesBefore != 0) {
585 CommasBeforeMatch = 0;
589 bool EmptyLineBreak =
590 (CurrentChange.NewlinesBefore > 1) && !ACS.AcrossEmptyLines;
595 !MatchingColumn && !(LineIsComment && ACS.AcrossComments);
597 if (EmptyLineBreak || NoMatchBreak)
598 AlignCurrentSequence();
602 if (MatchingColumn && CurrentChange.IndentedFromColumn < *MatchingColumn)
603 MatchingColumn.reset();
604 LineIsComment =
true;
607 if (CurrentChange.Tok->isNot(tok::comment))
608 LineIsComment =
false;
610 if constexpr (Strategy == AlignStrategy::Normal) {
611 if (CurrentChange.Tok->is(tok::comma)) {
613 }
else if (CurrentChange.indentAndNestingLevel() >
614 IndentAndNestingLevel) {
617 Style, Matches, Changes, I, ACS, RightJustify);
623 if (!Matches(CurrentChange))
626 const auto IndexToAlign = Strategy == AlignStrategy::CaseBody ? I + 1 : I;
627 const auto &ChangeToAlign = Changes[IndexToAlign];
628 const auto [AlignTheToken,
629 ShiftAlignment] = [&]() -> std::pair<bool, bool> {
631 case AlignStrategy::CaseBody: {
632 if (ChangeToAlign.NewlinesBefore == 0)
633 return {
true,
false};
634 const auto *
Tok = ChangeToAlign.Tok;
635 if (
Tok->is(tok::comment) && ACS.AcrossComments)
636 Tok =
Tok->getNextNonComment();
637 return {
false,
Tok &&
Tok->isOneOf(tok::kw_case, tok::kw_default)};
639 case AlignStrategy::CaseColon: {
640 if (I + 1 == LoopEnd)
641 return {
true,
false};
642 const auto &NextChange = Changes[I + 1];
643 if (NextChange.NewlinesBefore == 0 ||
644 (CurrentChange.Tok->Next &&
645 CurrentChange.Tok->Next->isTrailingComment())) {
646 return {
true,
false};
648 const auto *
Tok = NextChange.Tok;
649 if (
Tok->is(tok::comment) && ACS.AcrossComments)
650 Tok =
Tok->getNextNonComment();
651 return {
Tok &&
Tok->isOneOf(tok::kw_case, tok::kw_default),
false};
654 return {
true,
false};
658 if (!AlignTheToken && !ShiftAlignment)
663 if ((ChangeToAlign.NewlinesBefore == 0U && MatchingColumn) ||
664 CommasBeforeMatch != CommasBeforeLastMatch) {
665 MatchedIndices.push_back(IndexToAlign);
666 AlignCurrentSequence();
669 CommasBeforeLastMatch = CommasBeforeMatch;
670 MatchingColumn = AlignTheToken ? ChangeToAlign.StartOfTokenColumn
671 : std::numeric_limits<unsigned>::max();
673 if (StartOfSequence == 0 && AlignTheToken)
674 StartOfSequence = IndexToAlign;
676 unsigned ChangeWidthLeft = ChangeToAlign.StartOfTokenColumn;
677 unsigned ChangeWidthAnchor = 0;
678 unsigned ChangeWidthRight = 0;
679 unsigned CurrentChangeWidthRight = 0;
680 if (!AlignTheToken) {
684 ChangeWidthLeft = CurrentChange.StartOfTokenColumn +
685 CurrentChange.TokenLength +
689 if (ACS.PadOperators)
690 ChangeWidthAnchor = ChangeToAlign.TokenLength;
692 ChangeWidthLeft += ChangeToAlign.TokenLength;
694 CurrentChangeWidthRight = ChangeToAlign.TokenLength;
695 const FormatToken *MatchingParenToEncounter =
nullptr;
696 for (
unsigned J = IndexToAlign + 1;
697 J != E && (Changes[J].NewlinesBefore == 0 ||
698 MatchingParenToEncounter || Changes[J].AlignedTo);
700 const auto &
Change = Changes[J];
703 if (
Tok->MatchingParen) {
704 if (
Tok->isOneOf(tok::l_paren, tok::l_brace, tok::l_square,
705 TT_TemplateOpener) &&
706 !MatchingParenToEncounter) {
711 MatchingParenToEncounter =
Tok->MatchingParen;
712 }
else if (MatchingParenToEncounter ==
Tok->MatchingParen) {
713 MatchingParenToEncounter =
nullptr;
719 std::max(ChangeWidthRight, CurrentChangeWidthRight);
720 const auto ChangeWidthStart = ChangeWidthLeft + ChangeWidthAnchor;
731 CurrentChangeWidthRight =
Change.
Spaces - ChangeWidthStart;
745 ChangeWidthRight = std::max(ChangeWidthRight, CurrentChangeWidthRight);
749 unsigned NewLeft = std::max(ChangeWidthLeft, WidthLeft);
750 unsigned NewAnchor = std::max(ChangeWidthAnchor, WidthAnchor);
751 unsigned NewRight = std::max(ChangeWidthRight, WidthRight);
753 if (Style.ColumnLimit != 0 &&
754 Style.ColumnLimit < NewLeft + NewAnchor + NewRight) {
755 AlignCurrentSequence();
756 StartOfSequence = AlignTheToken ? IndexToAlign : 0;
757 WidthLeft = ChangeWidthLeft;
758 WidthAnchor = ChangeWidthAnchor;
759 WidthRight = ChangeWidthRight;
762 WidthAnchor = NewAnchor;
763 WidthRight = NewRight;
766 MatchedIndices.push_back(IndexToAlign);
771 for (EndOfSequence = I;
772 EndOfSequence < E && Changes[EndOfSequence].NewlinesBefore == 0;
775 AlignCurrentSequence();
781void WhitespaceManager::alignConsecutiveMacros() {
782 if (!Style.AlignConsecutiveMacros.Enabled)
785 auto AlignMacrosMatches = [](
const Change &
C) {
789 if (Current->SpacesRequiredBefore == 0 || !Current->Previous)
792 Current = Current->Previous;
796 if (Current->is(tok::r_paren)) {
805 }
else if (Current->Next->SpacesRequiredBefore != 1) {
811 return Current->endsSequence(tok::identifier, tok::pp_define);
815 Style, AlignMacrosMatches, Changes, 0, Style.AlignConsecutiveMacros);
818void WhitespaceManager::alignConsecutiveAssignments() {
819 if (!Style.AlignConsecutiveAssignments.Enabled &&
820 !Style.AlignConsecutiveAssignments.EnumAssignments) {
828 if (
C.NewlinesBefore > 0)
832 if (&
C != &Changes.back() && (&
C + 1)->NewlinesBefore > 0)
836 if (Style.AlignConsecutiveAssignments.EnumAssignments &&
837 C.Tok->is(TT_EnumEqual)) {
841 if (!Style.AlignConsecutiveAssignments.Enabled)
849 return Style.AlignConsecutiveAssignments.AlignCompound
851 : (
C.Tok->is(tok::equal) ||
855 (Style.isVerilog() &&
C.Tok->is(tok::lessequal) &&
858 Changes, 0, Style.AlignConsecutiveAssignments,
862void WhitespaceManager::alignConsecutiveBitFields() {
863 alignConsecutiveColons(Style.AlignConsecutiveBitFields, TT_BitFieldColon);
866void WhitespaceManager::alignConsecutiveColons(
867 const FormatStyle::AlignConsecutiveStyle &AlignStyle,
TokenType Type) {
875 if (
C.NewlinesBefore > 0)
879 if (&
C != &Changes.back() && (&
C + 1)->NewlinesBefore > 0)
882 return C.Tok->is(
Type);
884 Changes, 0, AlignStyle);
887void WhitespaceManager::alignConsecutiveShortCaseStatements(
bool IsExpr) {
888 if (!Style.AlignConsecutiveShortCaseStatements.Enabled ||
889 !(IsExpr ? Style.AllowShortCaseExpressionOnASingleLine
890 : Style.AllowShortCaseLabelsOnASingleLine)) {
894 const auto Type = IsExpr ? TT_CaseLabelArrow : TT_CaseLabelColon;
895 const auto &Option = Style.AlignConsecutiveShortCaseStatements;
896 const bool AlignArrowOrColon =
897 IsExpr ? Option.AlignCaseArrows : Option.AlignCaseColons;
899 FormatStyle::AlignConsecutiveStyle AlignStyle{};
904 if (AlignArrowOrColon) {
906 Style, Matches, Changes, 0, AlignStyle);
909 Style, Matches, Changes, 0, AlignStyle);
913void WhitespaceManager::alignConsecutiveTableGenBreakingDAGArgColons() {
914 alignConsecutiveColons(Style.AlignConsecutiveTableGenBreakingDAGArgColons,
915 TT_TableGenDAGArgListColonToAlign);
918void WhitespaceManager::alignConsecutiveTableGenCondOperatorColons() {
919 alignConsecutiveColons(Style.AlignConsecutiveTableGenCondOperatorColons,
920 TT_TableGenCondOperatorColon);
923void WhitespaceManager::alignConsecutiveTableGenDefinitions() {
924 alignConsecutiveColons(Style.AlignConsecutiveTableGenDefinitionColons,
925 TT_InheritanceColon);
928void WhitespaceManager::alignConsecutiveDeclarations() {
929 if (!Style.AlignConsecutiveDeclarations.Enabled)
935 if (
C.Tok->is(TT_FunctionTypeLParen))
936 return Style.AlignConsecutiveDeclarations.AlignFunctionPointers;
937 if (
C.Tok->is(TT_FunctionDeclarationName))
938 return Style.AlignConsecutiveDeclarations.AlignFunctionDeclarations;
939 if (
C.Tok->isNot(TT_StartOfName))
941 if (
C.Tok->Previous &&
942 C.Tok->Previous->is(TT_StatementAttributeLikeMacro))
946 if (
Next->is(tok::comment))
948 if (
Next->is(TT_PointerOrReference))
950 if (!
Next->Tok.getIdentifierInfo())
952 if (
Next->isOneOf(TT_StartOfName, TT_FunctionDeclarationName,
959 Changes, 0, Style.AlignConsecutiveDeclarations);
962void WhitespaceManager::alignChainedConditionals() {
963 if (Style.BreakBeforeTernaryOperators) {
968 return C.Tok->is(TT_ConditionalExpr) &&
969 ((
C.Tok->is(tok::question) && !
C.NewlinesBefore) ||
970 (
C.Tok->is(tok::colon) &&
C.Tok->Next &&
971 (
C.Tok->Next->FakeLParens.empty() ||
976 static auto AlignWrappedOperand = [](
Change const &
C) {
980 (
C.Tok->FakeLParens.empty() ||
987 if (AlignWrappedOperand(
C))
988 C.StartOfTokenColumn -= 2;
995 return (
C.Tok->is(TT_ConditionalExpr) &&
C.Tok->is(tok::question) &&
996 &
C != &Changes.back() && (&
C + 1)->NewlinesBefore == 0 &&
997 !(&
C + 1)->IsTrailingComment) ||
998 AlignWrappedOperand(
C);
1004void WhitespaceManager::alignTrailingComments() {
1008 const int Size = Changes.size();
1013 int StartOfSequence = 0;
1014 bool BreakBeforeNext =
false;
1015 bool IsInPP = Changes.front().Tok->Tok.is(tok::hash);
1016 int NewLineThreshold = 1;
1018 NewLineThreshold = Style.AlignTrailingComments.OverEmptyLines + 1;
1021 auto &
C = Changes[I];
1022 if (
C.StartOfBlockComment)
1024 if (
C.NewlinesBefore != 0) {
1026 const bool WasInPP = std::exchange(
1027 IsInPP,
C.Tok->Tok.is(tok::hash) || (IsInPP &&
C.IsTrailingComment) ||
1028 C.ContinuesPPDirective);
1029 if (IsInPP != WasInPP && !Style.AlignTrailingComments.AlignPPAndNotPP) {
1030 alignTrailingComments(StartOfSequence, I, MinColumn);
1033 StartOfSequence = I;
1037 if (NewLineThreshold > 1 &&
C.Tok->is(
BK_Block)) {
1038 alignTrailingComments(StartOfSequence, I, MinColumn);
1041 StartOfSequence = I + 1;
1045 if (!
C.IsTrailingComment)
1049 const int OriginalSpaces =
1050 C.OriginalWhitespaceRange.getEnd().getRawEncoding() -
1051 C.OriginalWhitespaceRange.getBegin().getRawEncoding() -
1052 C.Tok->LastNewlineOffset;
1053 assert(OriginalSpaces >= 0);
1054 const auto RestoredLineLength =
1055 C.StartOfTokenColumn +
C.TokenLength + OriginalSpaces;
1058 if (RestoredLineLength >= Style.ColumnLimit && Style.ColumnLimit > 0)
1062 C.NewlinesBefore > 0 ?
C.Tok->OriginalColumn : OriginalSpaces;
1063 setChangeSpaces(I, Spaces);
1067 const int ChangeMinColumn =
C.StartOfTokenColumn;
1068 int ChangeMaxColumn;
1072 if (!
C.CreateReplacement)
1073 ChangeMaxColumn = ChangeMinColumn;
1074 else if (Style.ColumnLimit == 0)
1076 else if (Style.ColumnLimit >=
C.TokenLength)
1077 ChangeMaxColumn = Style.ColumnLimit -
C.TokenLength;
1079 ChangeMaxColumn = ChangeMinColumn;
1081 if (I + 1 < Size && Changes[I + 1].ContinuesPPDirective &&
1082 ChangeMaxColumn >= 2) {
1083 ChangeMaxColumn -= 2;
1086 bool WasAlignedWithStartOfNextLine =
false;
1087 if (
C.NewlinesBefore >= 1) {
1088 const auto CommentColumn =
1089 SourceMgr.getSpellingColumnNumber(
C.OriginalWhitespaceRange.getEnd());
1090 for (
int J = I + 1; J <
Size; ++J) {
1091 if (Changes[J].
Tok->is(tok::comment))
1095 C.AlignedTo =
C.Tok->getPrevious(tok::comment);
1096 const auto NextColumn = SourceMgr.getSpellingColumnNumber(
1097 Changes[J].OriginalWhitespaceRange.getEnd());
1100 WasAlignedWithStartOfNextLine =
1101 CommentColumn == NextColumn ||
1102 CommentColumn == NextColumn + Style.IndentWidth;
1109 auto DontAlignThisComment = [](
const auto *
Tok) {
1110 if (
Tok->is(tok::semi)) {
1111 Tok =
Tok->getPreviousNonComment();
1115 if (
Tok->is(tok::r_paren)) {
1117 Tok =
Tok->MatchingParen;
1120 Tok =
Tok->getPreviousNonComment();
1123 if (
Tok->is(TT_DoWhile)) {
1124 const auto *Prev =
Tok->getPreviousNonComment();
1133 if (
Tok->isNot(tok::r_brace))
1136 while (
Tok->Previous &&
Tok->Previous->is(tok::r_brace))
1138 return Tok->NewlinesBefore > 0;
1141 if (I > 0 &&
C.NewlinesBefore == 0 &&
1142 DontAlignThisComment(Changes[I - 1].
Tok)) {
1143 alignTrailingComments(StartOfSequence, I, MinColumn);
1148 StartOfSequence = I + 1;
1149 }
else if (BreakBeforeNext ||
Newlines > NewLineThreshold ||
1150 (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn) ||
1153 (
C.NewlinesBefore == 1 && I > 0 &&
1154 !Changes[I - 1].IsTrailingComment) ||
1155 WasAlignedWithStartOfNextLine) {
1156 alignTrailingComments(StartOfSequence, I, MinColumn);
1157 MinColumn = ChangeMinColumn;
1158 MaxColumn = ChangeMaxColumn;
1159 StartOfSequence = I;
1161 MinColumn = std::max(MinColumn, ChangeMinColumn);
1162 MaxColumn = std::min(MaxColumn, ChangeMaxColumn);
1164 BreakBeforeNext = (I == 0) || (
C.NewlinesBefore > 1) ||
1167 (
C.NewlinesBefore == 1 && StartOfSequence == I);
1170 alignTrailingComments(StartOfSequence, Size, MinColumn);
1173void WhitespaceManager::alignTrailingComments(
unsigned Start,
unsigned End,
1175 for (
unsigned i = Start; i != End; ++i) {
1177 if (Changes[i].IsTrailingComment)
1179 if (Changes[i].StartOfBlockComment) {
1180 Shift = Changes[i].IndentationOffset +
1181 Changes[i].StartOfBlockComment->StartOfTokenColumn -
1182 Changes[i].StartOfTokenColumn;
1187 setChangeSpaces(i, Changes[i].Spaces + Shift);
1191void WhitespaceManager::alignEscapedNewlines() {
1192 const auto Align = Style.AlignEscapedNewlines;
1198 const auto MaxColumn = Style.ColumnLimit;
1199 unsigned MaxEndOfLine = AlignLeft ? 0 : MaxColumn;
1200 unsigned StartOfMacro = 0;
1201 for (
unsigned i = 1, e = Changes.size(); i < e; ++i) {
1203 if (
C.NewlinesBefore == 0 && (!WithLastLine ||
C.Tok->isNot(tok::eof)))
1206 const auto BackslashColumn =
C.PreviousEndOfTokenColumn + 2;
1207 if (InPPDirective ||
1208 (WithLastLine && (MaxColumn == 0 || BackslashColumn <= MaxColumn))) {
1209 MaxEndOfLine = std::max(BackslashColumn, MaxEndOfLine);
1211 if (!InPPDirective) {
1212 alignEscapedNewlines(StartOfMacro + 1, i, MaxEndOfLine);
1213 MaxEndOfLine = AlignLeft ? 0 : MaxColumn;
1217 alignEscapedNewlines(StartOfMacro + 1, Changes.size(), MaxEndOfLine);
1220void WhitespaceManager::alignEscapedNewlines(
unsigned Start,
unsigned End,
1222 for (
unsigned i = Start; i < End; ++i) {
1224 if (
C.NewlinesBefore > 0) {
1225 assert(
C.ContinuesPPDirective);
1226 if (
C.PreviousEndOfTokenColumn + 1 >
Column)
1227 C.EscapedNewlineColumn = 0;
1229 C.EscapedNewlineColumn =
Column;
1234void WhitespaceManager::alignArrayInitializers() {
1238 for (
unsigned ChangeIndex = 1U, ChangeEnd = Changes.size();
1239 ChangeIndex < ChangeEnd; ++ChangeIndex) {
1240 auto &
C = Changes[ChangeIndex];
1241 if (
C.Tok->IsArrayInitializer) {
1242 bool FoundComplete =
false;
1243 for (
unsigned InsideIndex = ChangeIndex + 1; InsideIndex < ChangeEnd;
1245 const auto *
Tok = Changes[InsideIndex].Tok;
1246 if (
Tok->is(tok::pp_define))
1248 if (
Tok ==
C.Tok->MatchingParen) {
1249 alignArrayInitializers(ChangeIndex, InsideIndex + 1);
1250 ChangeIndex = InsideIndex + 1;
1251 FoundComplete =
true;
1256 ChangeIndex = ChangeEnd;
1261void WhitespaceManager::alignArrayInitializers(
unsigned Start,
unsigned End) {
1264 alignArrayInitializersRightJustified(getCells(Start, End));
1266 alignArrayInitializersLeftJustified(getCells(Start, End));
1269void WhitespaceManager::alignArrayInitializersRightJustified(
1270 CellDescriptions &&CellDescs) {
1271 if (!CellDescs.isRectangular())
1274 const int BracePadding =
1276 auto &Cells = CellDescs.Cells;
1278 auto *CellIter = Cells.begin();
1279 for (
auto i = 0U; i < CellDescs.CellCounts[0]; ++i, ++CellIter) {
1280 unsigned NetWidth = 0U;
1281 if (isSplitCell(*CellIter))
1282 NetWidth = getNetWidth(Cells.begin(), CellIter, CellDescs.InitialSpaces);
1283 auto CellWidth = getMaximumCellWidth(CellIter, NetWidth);
1285 if (Changes[CellIter->Index].Tok->is(tok::r_brace)) {
1289 const auto *
Next = CellIter;
1293 Changes[
Next->Index].NewlinesBefore = 0;
1294 setChangeSpaces(
Next->Index, BracePadding);
1300 if (CellIter != Cells.begin()) {
1302 getNetWidth(Cells.begin(), CellIter, CellDescs.InitialSpaces);
1303 auto MaxNetWidth = getMaximumNetWidth(
1304 Cells.begin(), CellIter, CellDescs.InitialSpaces,
1305 CellDescs.CellCounts[0], CellDescs.CellCounts.size());
1306 if (ThisNetWidth < MaxNetWidth)
1307 setChangeSpaces(CellIter->Index, MaxNetWidth - ThisNetWidth);
1309 auto Offset = std::distance(Cells.begin(), CellIter);
1310 for (
const auto *
Next = CellIter->NextColumnElement;
Next;
1312 if (RowCount >= CellDescs.CellCounts.size())
1314 auto *Start = (Cells.begin() + RowCount * CellDescs.CellCounts[0]);
1315 auto *End = Start + Offset;
1316 ThisNetWidth = getNetWidth(Start, End, CellDescs.InitialSpaces);
1317 if (ThisNetWidth < MaxNetWidth)
1318 setChangeSpaces(
Next->Index, MaxNetWidth - ThisNetWidth);
1324 calculateCellWidth(CellIter->Index, CellIter->EndIndex,
true) +
1326 if (Changes[CellIter->Index].NewlinesBefore == 0) {
1327 int Spaces = (CellWidth - (ThisWidth + NetWidth));
1328 Spaces += (i > 0) ? 1 : BracePadding;
1330 setChangeSpaces(CellIter->Index, Spaces);
1332 alignToStartOfCell(CellIter->Index, CellIter->EndIndex);
1333 for (
const auto *
Next = CellIter->NextColumnElement;
Next;
1336 calculateCellWidth(
Next->Index,
Next->EndIndex,
true) + NetWidth;
1337 if (Changes[
Next->Index].NewlinesBefore == 0) {
1338 int Spaces = (CellWidth - ThisWidth);
1339 Spaces += (i > 0) ? 1 : BracePadding;
1341 setChangeSpaces(
Next->Index, Spaces);
1343 alignToStartOfCell(
Next->Index,
Next->EndIndex);
1349void WhitespaceManager::alignArrayInitializersLeftJustified(
1350 CellDescriptions &&CellDescs) {
1352 if (!CellDescs.isRectangular())
1355 const int BracePadding =
1357 auto &Cells = CellDescs.Cells;
1359 auto *CellIter = Cells.begin();
1365 setChangeSpaces(
Next->Index, Spaces);
1368 for (
auto i = 1U; i < CellDescs.CellCounts[0]; i++, ++CellIter) {
1369 auto MaxNetWidth = getMaximumNetWidth(
1370 Cells.begin(), CellIter, CellDescs.InitialSpaces,
1371 CellDescs.CellCounts[0], CellDescs.CellCounts.size());
1373 getNetWidth(Cells.begin(), CellIter, CellDescs.InitialSpaces);
1374 if (Changes[CellIter->Index].NewlinesBefore == 0) {
1376 MaxNetWidth - ThisNetWidth +
1377 (Changes[CellIter->Index].Tok->isNot(tok::r_brace) ? 1
1379 setChangeSpaces(CellIter->Index, Spaces);
1382 auto Offset = std::distance(Cells.begin(), CellIter);
1383 for (
const auto *
Next = CellIter->NextColumnElement;
Next;
1385 if (RowCount >= CellDescs.CellCounts.size())
1387 auto *Start = (Cells.begin() + RowCount * CellDescs.CellCounts[0]);
1388 auto *End = Start + Offset;
1389 auto ThisNetWidth = getNetWidth(Start, End, CellDescs.InitialSpaces);
1390 if (Changes[
Next->Index].NewlinesBefore == 0) {
1392 MaxNetWidth - ThisNetWidth +
1393 (Changes[
Next->Index].Tok->isNot(tok::r_brace) ? 1 : BracePadding);
1394 setChangeSpaces(
Next->Index, Spaces);
1401bool WhitespaceManager::isSplitCell(
const CellDescription &Cell) {
1404 for (
const auto *
Next = Cell.NextColumnElement;
Next;
1412WhitespaceManager::CellDescriptions WhitespaceManager::getCells(
unsigned Start,
1417 SmallVector<unsigned> CellCounts;
1418 unsigned InitialSpaces = 0;
1419 unsigned InitialTokenLength = 0;
1420 unsigned EndSpaces = 0;
1421 SmallVector<CellDescription> Cells;
1423 for (
unsigned i = Start; i < End; ++i) {
1424 auto &
C = Changes[i];
1425 if (
C.Tok->is(tok::l_brace))
1427 else if (
C.Tok->is(tok::r_brace))
1430 if (
C.Tok->is(tok::l_brace)) {
1433 if (InitialSpaces == 0) {
1434 InitialSpaces =
C.Spaces +
C.TokenLength;
1435 InitialTokenLength =
C.TokenLength;
1437 for (; Changes[j].NewlinesBefore == 0 && j > Start; --j) {
1438 InitialSpaces += Changes[j].Spaces + Changes[j].TokenLength;
1439 InitialTokenLength += Changes[j].TokenLength;
1441 if (
C.NewlinesBefore == 0) {
1442 InitialSpaces += Changes[j].Spaces + Changes[j].TokenLength;
1443 InitialTokenLength += Changes[j].TokenLength;
1446 }
else if (
C.Tok->is(tok::comma)) {
1448 Cells.back().EndIndex = i;
1449 if (
const auto *
Next =
C.Tok->getNextNonComment();
1450 Next &&
Next->isNot(tok::r_brace)) {
1454 }
else if (Depth == 1) {
1457 Cells.back().EndIndex = i;
1458 Cells.push_back(CellDescription{i, ++Cell, i + 1,
false,
nullptr});
1459 CellCounts.push_back(
C.Tok->Previous->isNot(tok::comma) ? Cell + 1
1462 const auto *NextNonComment =
C.Tok->getNextNonComment();
1463 while (NextNonComment && NextNonComment->is(tok::comma))
1464 NextNonComment = NextNonComment->getNextNonComment();
1466 while (j < End && Changes[j].
Tok != NextNonComment)
1469 Changes[j].
Tok->isNot(tok::r_brace)) {
1470 Changes[j].NewlinesBefore = 1;
1472 setChangeSpaces(j, InitialSpaces - InitialTokenLength);
1474 }
else if (
C.Tok->is(tok::comment) &&
C.Tok->NewlinesBefore == 0) {
1476 setChangeSpaces(i, Changes[i - 1].
Tok->is(tok::comma) ? 1 : 2);
1477 }
else if (
C.Tok->is(tok::l_brace)) {
1481 for (; j > 0 && !Changes[j].Tok->ArrayInitializerLineStart; --j)
1483 EndSpaces = Changes[j].Spaces;
1485 }
else if (Depth == 0 &&
C.Tok->is(tok::r_brace)) {
1486 C.NewlinesBefore = 1;
1487 setChangeSpaces(i, EndSpaces);
1489 if (
C.Tok->StartsColumn) {
1492 bool HasSplit =
false;
1509 if ((j - 1) > Start && Changes[j].
Tok->is(tok::comma) &&
1510 Changes[j - 1].NewlinesBefore > 0) {
1512 auto LineLimit = Changes[j].Spaces + Changes[j].TokenLength;
1513 if (LineLimit < Style.ColumnLimit) {
1514 Changes[i].NewlinesBefore = 0;
1515 setChangeSpaces(i, 1);
1520 setChangeSpaces(i, InitialSpaces);
1524 if (Changes[i].
Tok !=
C.Tok)
1526 Cells.push_back(CellDescription{i, Cell, i, HasSplit,
nullptr});
1530 return linkCells({Cells, CellCounts, InitialSpaces});
1533unsigned WhitespaceManager::calculateCellWidth(
unsigned Start,
unsigned End,
1534 bool WithSpaces)
const {
1535 unsigned CellWidth = 0;
1536 for (
auto i = Start; i < End; i++) {
1539 CellWidth += Changes[i].TokenLength;
1540 CellWidth += (WithSpaces ? Changes[i].Spaces : 0);
1545void WhitespaceManager::alignToStartOfCell(
unsigned Start,
unsigned End) {
1546 if ((End - Start) <= 1)
1550 for (
auto i = Start + 1; i < End; i++)
1552 setChangeSpaces(i, Changes[Start].Spaces);
1555WhitespaceManager::CellDescriptions
1556WhitespaceManager::linkCells(CellDescriptions &&CellDesc) {
1557 auto &Cells = CellDesc.Cells;
1558 for (
auto *CellIter = Cells.begin(); CellIter != Cells.end(); ++CellIter) {
1559 if (!CellIter->NextColumnElement && (CellIter + 1) != Cells.end()) {
1560 for (
auto *NextIter = CellIter + 1; NextIter != Cells.end(); ++NextIter) {
1561 if (NextIter->Cell == CellIter->Cell) {
1562 CellIter->NextColumnElement = &(*NextIter);
1568 return std::move(CellDesc);
1571void WhitespaceManager::setChangeSpaces(
unsigned Start,
unsigned Spaces) {
1575void WhitespaceManager::generateChanges() {
1576 for (
unsigned i = 0, e = Changes.size(); i != e; ++i) {
1579 auto Last = Changes[i - 1].OriginalWhitespaceRange;
1580 auto New = Changes[i].OriginalWhitespaceRange;
1622 if (
Last.getBegin() ==
New.getBegin() &&
1623 (
Last.getEnd() !=
Last.getBegin() ||
1624 New.getEnd() ==
New.getBegin())) {
1628 if (
C.CreateReplacement) {
1629 std::string ReplacementText =
C.PreviousLinePostfix;
1630 if (
C.ContinuesPPDirective) {
1631 appendEscapedNewlineText(ReplacementText,
C.NewlinesBefore,
1632 C.PreviousEndOfTokenColumn,
1633 C.EscapedNewlineColumn);
1635 appendNewlineText(ReplacementText,
C);
1640 appendIndentText(ReplacementText,
IndentLevel, std::max(0,
C.Spaces),
1641 std::max((
int)
C.StartOfTokenColumn,
C.Spaces) -
1642 std::max(0,
C.Spaces),
1644 C.Tok->AppliedIndentLevel =
1645 C.AlignedTo ?
IndentLevel : std::max(0,
C.Spaces) / Style.IndentWidth;
1646 ReplacementText.append(
C.CurrentLinePrefix);
1647 storeReplacement(
C.OriginalWhitespaceRange, ReplacementText);
1652void WhitespaceManager::storeReplacement(SourceRange Range, StringRef
Text) {
1653 unsigned WhitespaceLength = SourceMgr.getFileOffset(
Range.getEnd()) -
1654 SourceMgr.getFileOffset(
Range.getBegin());
1656 if (StringRef(SourceMgr.getCharacterData(
Range.getBegin()),
1657 WhitespaceLength) ==
Text) {
1660 auto Err = Replaces.add(tooling::Replacement(
1665 llvm::errs() << llvm::toString(std::move(Err)) <<
"\n";
1670void WhitespaceManager::appendNewlineText(std::string &
Text,
const Change &
C) {
1671 if (
C.NewlinesBefore <= 0)
1674 StringRef Newline = UseCRLF ?
"\r\n" :
"\n";
1675 Text.append(Newline);
1677 if (
C.Tok->HasFormFeedBefore)
1680 for (
unsigned I = 1; I <
C.NewlinesBefore; ++I)
1681 Text.append(Newline);
1684void WhitespaceManager::appendEscapedNewlineText(
1685 std::string &
Text,
unsigned Newlines,
unsigned PreviousEndOfTokenColumn,
1686 unsigned EscapedNewlineColumn) {
1689 std::max<int>(1, EscapedNewlineColumn - PreviousEndOfTokenColumn - 1);
1690 for (
unsigned i = 0; i <
Newlines; ++i) {
1691 Text.append(Spaces,
' ');
1692 Text.append(UseCRLF ?
"\\\r\n" :
"\\\n");
1693 Spaces = std::max<int>(0, EscapedNewlineColumn - 1);
1698void WhitespaceManager::appendIndentText(std::string &
Text,
1700 unsigned WhitespaceStartColumn,
1702 switch (Style.UseTab) {
1704 Text.append(Spaces,
' ');
1707 if (Style.TabWidth) {
1708 unsigned FirstTabWidth =
1709 Style.TabWidth - WhitespaceStartColumn % Style.TabWidth;
1712 if (Spaces < FirstTabWidth || Spaces == 1) {
1713 Text.append(Spaces,
' ');
1717 Spaces -= FirstTabWidth;
1720 Text.append(Spaces / Style.TabWidth,
'\t');
1721 Text.append(Spaces % Style.TabWidth,
' ');
1722 }
else if (Spaces == 1) {
1723 Text.append(Spaces,
' ');
1728 if (WhitespaceStartColumn == 0) {
1729 unsigned Indentation =
IndentLevel * Style.IndentWidth;
1730 Spaces = appendTabIndent(
Text, Spaces, Indentation);
1732 Text.append(Spaces,
' ');
1735 if (WhitespaceStartColumn == 0)
1736 Spaces = appendTabIndent(
Text, Spaces, Spaces);
1737 Text.append(Spaces,
' ');
1740 if (WhitespaceStartColumn == 0) {
1741 unsigned Indentation =
1742 IsAligned ?
IndentLevel * Style.IndentWidth : Spaces;
1743 Spaces = appendTabIndent(
Text, Spaces, Indentation);
1745 Text.append(Spaces,
' ');
1750unsigned WhitespaceManager::appendTabIndent(std::string &
Text,
unsigned Spaces,
1751 unsigned Indentation) {
1754 if (Indentation > Spaces)
1755 Indentation = Spaces;
1756 if (Style.TabWidth) {
1757 unsigned Tabs = Indentation / Style.TabWidth;
1758 Text.append(Tabs,
'\t');
1759 Spaces -= Tabs * Style.TabWidth;
WhitespaceManager class manages whitespace around tokens and their replacements.
__DEVICE__ long long abs(long long __n)
static CharSourceRange getCharRange(SourceRange R)
Encodes a location in the source.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Top level wrappers for InstallAPI frontend operations.
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
@ Result
The result type of a method or function.