23#include "llvm/ADT/StringSet.h"
24#include "llvm/Support/Debug.h"
27#define DEBUG_TYPE "format-indenter"
44 Previous->isOneOf(tok::kw_return, TT_RequiresClause));
93 int MatchingStackIndex = Stack.size() - 1;
99 while (MatchingStackIndex >= 0 && Stack[MatchingStackIndex].Tok != LBrace)
100 --MatchingStackIndex;
101 return MatchingStackIndex >= 0 ? &Stack[MatchingStackIndex] :
nullptr;
103 for (; End->Next; End = End->Next) {
104 if (End->Next->CanBreakBefore)
106 if (!End->Next->closesScope())
108 if (End->Next->MatchingParen &&
109 End->Next->MatchingParen->isOneOf(
110 tok::l_brace, TT_ArrayInitializerLSquare, tok::less)) {
111 const ParenState *State = FindParenState(End->Next->MatchingParen);
112 if (State && State->BreakBeforeClosingBrace)
135 if (Current.
is(TT_CtorInitializerComma) &&
142 ((
Previous.isNot(TT_CtorInitializerComma) ||
145 (
Previous.isNot(TT_InheritanceComma) ||
151 if (LessTok.
isNot(tok::less))
163 if (TokenText.size() < 5
164 || !TokenText.starts_with(
"R\"") || !TokenText.ends_with(
"\"")) {
171 size_t LParenPos = TokenText.substr(0, 19).find_first_of(
'(');
172 if (LParenPos == StringRef::npos)
174 StringRef Delimiter = TokenText.substr(2, LParenPos - 2);
177 size_t RParenPos = TokenText.size() - Delimiter.size() - 2;
178 if (TokenText[RParenPos] !=
')')
180 if (!TokenText.substr(RParenPos + 1).starts_with(Delimiter))
192 return StringRef(Format.CanonicalDelimiter);
199 std::optional<FormatStyle> LanguageStyle =
201 if (!LanguageStyle) {
204 RawStringFormat.Language, &PredefinedStyle)) {
206 PredefinedStyle.
Language = RawStringFormat.Language;
208 LanguageStyle = PredefinedStyle;
211 for (StringRef Delimiter : RawStringFormat.Delimiters)
213 for (StringRef EnclosingFunction : RawStringFormat.EnclosingFunctions)
218std::optional<FormatStyle>
226std::optional<FormatStyle>
228 StringRef EnclosingFunction)
const {
240 bool BinPackInconclusiveFunctions)
241 : Style(Style), Keywords(Keywords), SourceMgr(SourceMgr),
242 Whitespaces(Whitespaces), Encoding(Encoding),
243 BinPackInconclusiveFunctions(BinPackInconclusiveFunctions),
244 CommentPragmasRegex(Style.CommentPragmas), RawStringFormats(Style) {}
247 unsigned FirstStartColumn,
251 State.FirstIndent = FirstIndent;
252 if (FirstStartColumn &&
Line->First->NewlinesBefore == 0)
253 State.Column = FirstStartColumn;
255 State.Column = FirstIndent;
265 State.NextToken =
Line->First;
266 State.Stack.push_back(
ParenState(
nullptr, FirstIndent, FirstIndent,
269 State.NoContinuation =
false;
270 State.StartOfStringLiteral = 0;
271 State.NoLineBreak =
false;
272 State.StartOfLineLevel = 0;
273 State.LowestLevelOnLine = 0;
274 State.IgnoreStackForComparison =
false;
279 auto &CurrentState = State.Stack.back();
280 CurrentState.AvoidBinPacking =
true;
281 CurrentState.BreakBeforeParameter =
true;
282 CurrentState.AlignColons =
false;
286 moveStateToNextToken(State, DryRun,
false);
293 const auto &CurrentState = State.Stack.back();
294 assert(&
Previous == Current.Previous);
295 if (!Current.CanBreakBefore && !(CurrentState.BreakBeforeClosingBrace &&
296 Current.closesBlockOrBlockTypeList(Style))) {
301 if (!Current.MustBreakBefore &&
Previous.is(tok::l_brace) &&
304 Previous.Previous->isOneOf(tok::l_brace, tok::l_paren, tok::comma)) {
313 State.LowestLevelOnLine < State.StartOfLineLevel &&
314 State.LowestLevelOnLine < Current.NestingLevel) {
317 if (Current.isMemberAccess() && CurrentState.ContainsUnwrappedBuilder)
322 if (
Previous.is(tok::l_brace) && State.Stack.size() > 1 &&
323 State.Stack[State.Stack.size() - 2].NestedBlockInlined &&
324 State.Stack[State.Stack.size() - 2].HasMultipleNestedBlocks &&
331 if (Current.is(TT_FunctionDeclarationName)) {
338 assert(State.Column >= State.FirstIndent);
339 if (State.Column - State.FirstIndent < 6)
346 if (!Current.isOneOf(TT_BinaryOperator, tok::comma) &&
351 Current.isNot(TT_LambdaLBrace)) &&
352 CurrentState.NoLineBreakInOperand) {
359 if (Current.is(TT_ConditionalExpr) &&
Previous.is(tok::r_paren) &&
361 Previous.MatchingParen->Previous->MatchingParen &&
362 Previous.MatchingParen->Previous->MatchingParen->is(TT_LambdaLBrace)) {
364 assert(
Previous.MatchingParen->Previous->is(tok::r_brace));
368 return !State.NoLineBreak && !CurrentState.NoLineBreak;
374 const auto &CurrentState = State.Stack.back();
376 Current.is(TT_LambdaLBrace) &&
Previous.isNot(TT_LineComment)) {
380 if (Current.MustBreakBefore ||
381 (Current.is(TT_InlineASMColon) &&
387 if (CurrentState.BreakBeforeClosingBrace &&
388 (Current.closesBlockOrBlockTypeList(Style) ||
389 (Current.is(tok::r_brace) &&
390 Current.isBlockIndentedInitRBrace(Style)))) {
393 if (CurrentState.BreakBeforeClosingParen && Current.is(tok::r_paren))
397 Current.ObjCSelectorNameParts > 1 &&
398 Current.startsSequence(TT_SelectorName, tok::colon, tok::caret)) {
403 if (CurrentState.IsCSharpGenericTypeConstraint &&
404 Previous.isNot(TT_CSharpGenericTypeConstraintComma)) {
408 (
Previous.is(TT_TemplateCloser) && Current.is(TT_StartOfName) &&
409 State.Line->First->isNot(TT_AttributeSquare) && Style.
isCpp() &&
418 Previous.is(TT_ConditionalExpr))) &&
419 CurrentState.BreakBeforeParameter && !Current.isTrailingComment() &&
420 !Current.isOneOf(tok::r_paren, tok::r_brace)) {
423 if (CurrentState.IsChainedConditional &&
425 Current.is(tok::colon)) ||
431 (
Previous.is(TT_ArrayInitializerLSquare) &&
440 const FormatToken &BreakConstructorInitializersToken =
444 if (BreakConstructorInitializersToken.
is(TT_CtorInitializerColon) &&
445 (State.Column + State.Line->Last->TotalLength -
Previous.TotalLength >
447 CurrentState.BreakBeforeParameter) &&
448 (!Current.isTrailingComment() || Current.NewlinesBefore > 0) &&
455 if (Current.is(TT_ObjCMethodExpr) &&
Previous.isNot(TT_SelectorName) &&
456 State.Line->startsWith(TT_ObjCMethodSpecifier)) {
459 if (Current.is(TT_SelectorName) &&
Previous.isNot(tok::at) &&
460 CurrentState.ObjCSelectorNameFound && CurrentState.BreakBeforeParameter &&
462 !Current.startsSequence(TT_SelectorName, tok::colon, tok::caret))) {
466 unsigned NewLineColumn = getNewLineColumn(State);
467 if (Current.isMemberAccess() && Style.
ColumnLimit != 0 &&
469 (State.Column > NewLineColumn ||
470 Current.NestingLevel < State.StartOfLineLevel)) {
475 (CurrentState.CallContinuation != 0 ||
476 CurrentState.BreakBeforeParameter) &&
482 !(State.Column <= NewLineColumn && Style.
isJavaScript()) &&
483 !(
Previous.closesScopeAfterBlock() && State.Column <= NewLineColumn)) {
489 if (
Previous.ClosesTemplateDeclaration && CurrentState.BreakBeforeParameter &&
490 Current.CanBreakBefore) {
494 if (State.Line->First->isNot(tok::kw_enum) && State.Column <= NewLineColumn)
499 Previous.is(tok::comma) || Current.NestingLevel < 2) &&
500 !
Previous.isOneOf(tok::kw_return, tok::lessless, tok::at,
502 !
Previous.isOneOf(TT_InlineASMColon, TT_ConditionalExpr) &&
503 nextIsMultilineString(State)) {
510 if (
Previous.is(TT_BinaryOperator) && Current.CanBreakBefore) {
511 const auto PreviousPrecedence =
Previous.getPrecedence();
513 CurrentState.BreakBeforeParameter && !Current.isTrailingComment()) {
514 const bool LHSIsBinaryExpr =
527 const bool IsComparison =
532 Previous.Previous->isNot(TT_BinaryOperator);
536 }
else if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore &&
537 CurrentState.BreakBeforeParameter) {
542 if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator) &&
543 CurrentState.BreakBeforeParameter && CurrentState.FirstLessLess == 0) {
547 if (Current.NestingLevel == 0 && !Current.isTrailingComment()) {
552 if (
Previous.ClosesTemplateDeclaration) {
553 if (Current.is(tok::kw_concept)) {
563 if (Current.is(TT_RequiresClause)) {
574 Current.NewlinesBefore > 0);
576 if (
Previous.is(TT_FunctionAnnotationRParen) &&
580 if (
Previous.is(TT_LeadingJavaAnnotation) && Current.isNot(tok::l_paren) &&
581 Current.isNot(TT_LeadingJavaAnnotation)) {
590 static const llvm::StringSet<> BreakBeforeDecoratedTokens = {
"get",
"set",
592 if (BreakBeforeDecoratedTokens.contains(Current.TokenText))
596 if (Current.is(TT_FunctionDeclarationName) &&
597 !State.Line->ReturnTypeWrapped &&
604 CurrentState.BreakBeforeParameter) {
613 !Current.isOneOf(tok::r_brace, tok::comment)) {
617 if (Current.is(tok::lessless) &&
620 Previous.TokenText ==
"\'\\n\'")))) {
627 if (State.NoContinuation)
635 unsigned ExtraSpaces) {
637 assert(State.NextToken->Previous);
640 assert(!State.Stack.empty());
641 State.NoContinuation =
false;
643 if (Current.is(TT_ImplicitStringLiteral) &&
644 (!
Previous.Tok.getIdentifierInfo() ||
645 Previous.Tok.getIdentifierInfo()->getPPKeywordID() ==
646 tok::pp_not_keyword)) {
649 if (Current.LastNewlineOffset != 0) {
652 State.Column = EndColumn;
654 unsigned StartColumn =
656 assert(EndColumn >= StartColumn);
657 State.Column += EndColumn - StartColumn;
659 moveStateToNextToken(State, DryRun,
false);
663 unsigned Penalty = 0;
665 Penalty = addTokenOnNewLine(State, DryRun);
667 addTokenOnCurrentLine(State, DryRun, ExtraSpaces);
669 return moveStateToNextToken(State, DryRun, Newline) + Penalty;
672void ContinuationIndenter::addTokenOnCurrentLine(
LineState &State,
bool DryRun,
673 unsigned ExtraSpaces) {
675 assert(State.NextToken->Previous);
677 auto &CurrentState = State.Stack.back();
679 bool DisallowLineBreaksOnThisLine =
681 Style.
isCpp() && [&Current] {
687 const auto *Prev = Current.Previous;
691 if (Prev->is(TT_BlockComment) && Current.SpacesRequiredBefore == 0)
693 const auto *PrevNonComment = Current.getPreviousNonComment();
694 if (!PrevNonComment || PrevNonComment->isNot(tok::l_paren))
696 if (Current.isOneOf(tok::comment, tok::l_paren, TT_LambdaLSquare))
698 auto BlockParameterCount = PrevNonComment->BlockParameterCount;
699 if (BlockParameterCount == 0)
703 if (BlockParameterCount > 1)
707 if (!PrevNonComment->Role)
709 auto Comma = PrevNonComment->Role->lastComma();
712 auto Next = Comma->getNextNonComment();
714 !Next->isOneOf(TT_LambdaLSquare, tok::l_brace, tok::caret);
717 if (DisallowLineBreaksOnThisLine)
718 State.NoLineBreak =
true;
720 if (Current.is(tok::equal) &&
721 (State.Line->First->is(tok::kw_for) || Current.NestingLevel == 0) &&
722 CurrentState.VariablePos == 0 &&
724 Previous.Previous->isNot(TT_DesignatedInitializerPeriod))) {
725 CurrentState.VariablePos = State.Column;
728 while (Tok && CurrentState.VariablePos >= Tok->ColumnWidth) {
729 CurrentState.VariablePos -= Tok->ColumnWidth;
730 if (Tok->SpacesRequiredBefore != 0)
734 if (
Previous.PartOfMultiVariableDeclStmt)
735 CurrentState.LastSpace = CurrentState.VariablePos;
738 unsigned Spaces = Current.SpacesRequiredBefore + ExtraSpaces;
741 int PPColumnCorrection = 0;
743 Previous.is(tok::hash) && State.FirstIndent > 0 &&
747 Spaces += State.FirstIndent;
754 PPColumnCorrection = -1;
759 State.Column + Spaces + PPColumnCorrection,
760 false, State.Line->InMacroBody);
766 Current.is(TT_InheritanceColon)) {
767 CurrentState.NoLineBreak =
true;
771 CurrentState.NoLineBreak =
true;
774 if (Current.is(TT_SelectorName) && !CurrentState.ObjCSelectorNameFound) {
775 unsigned MinIndent = std::max(
777 unsigned FirstColonPos = State.Column + Spaces + Current.ColumnWidth;
778 if (Current.LongestObjCSelectorName == 0)
779 CurrentState.AlignColons =
false;
780 else if (MinIndent + Current.LongestObjCSelectorName > FirstColonPos)
781 CurrentState.ColonPos = MinIndent + Current.LongestObjCSelectorName;
783 CurrentState.ColonPos = FirstColonPos;
790 auto IsOpeningBracket = [&](
const FormatToken &Tok) {
791 auto IsStartOfBracedList = [&]() {
792 return Tok.is(tok::l_brace) && Tok.isNot(
BK_Block) &&
795 if (!Tok.isOneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) &&
796 !IsStartOfBracedList()) {
801 if (Tok.Previous->isIf())
803 return !Tok.Previous->isOneOf(TT_CastRParen, tok::kw_for, tok::kw_while,
808 IsOpeningBracket(
Previous) && State.Column > getNewLineColumn(State) &&
816 Current.FakeLParens.size() > 0 &&
818 CurrentState.NoLineBreak =
true;
821 CurrentState.NoLineBreak =
true;
828 !CurrentState.IsCSharpGenericTypeConstraint &&
Previous.opensScope() &&
830 Previous.isNot(TT_TableGenDAGArgOpener) &&
831 Previous.isNot(TT_TableGenDAGArgOpenerToBreak) &&
832 !(Current.MacroParent &&
Previous.MacroParent) &&
833 (Current.isNot(TT_LineComment) ||
835 CurrentState.Indent = State.Column + Spaces;
836 CurrentState.IsAligned =
true;
839 CurrentState.NoLineBreak =
true;
841 State.Column > getNewLineColumn(State)) {
842 CurrentState.ContainsUnwrappedBuilder =
true;
845 if (Current.is(TT_TrailingReturnArrow) &&
847 CurrentState.NoLineBreak =
true;
849 if (Current.isMemberAccess() &&
Previous.is(tok::r_paren) &&
858 CurrentState.NoLineBreak =
true;
865 const FormatToken *
P = Current.getPreviousNonComment();
866 if (Current.isNot(tok::comment) &&
P &&
867 (
P->isOneOf(TT_BinaryOperator, tok::comma) ||
868 (
P->is(TT_ConditionalExpr) &&
P->is(tok::colon))) &&
869 !
P->isOneOf(TT_OverloadedOperator, TT_CtorInitializerComma) &&
873 bool BreakBeforeOperator =
874 P->MustBreakBefore ||
P->is(tok::lessless) ||
875 (
P->is(TT_BinaryOperator) &&
881 bool HasTwoOperands =
P->OperatorIndex == 0 && !
P->NextOperator &&
882 P->isNot(TT_ConditionalExpr);
883 if ((!BreakBeforeOperator &&
886 (!CurrentState.LastOperatorWrapped && BreakBeforeOperator)) {
887 CurrentState.NoLineBreakInOperand =
true;
891 State.Column += Spaces;
892 if (Current.isNot(tok::comment) &&
Previous.is(tok::l_paren) &&
897 CurrentState.LastSpace = State.Column;
898 CurrentState.NestedBlockIndent = State.Column;
899 }
else if (!Current.isOneOf(tok::comment, tok::caret) &&
901 Previous.isNot(TT_OverloadedOperator)) ||
903 CurrentState.LastSpace = State.Column;
904 }
else if (
Previous.is(TT_CtorInitializerColon) &&
905 (!Current.isTrailingComment() || Current.NewlinesBefore > 0) &&
908 CurrentState.Indent = State.Column;
909 CurrentState.LastSpace = State.Column;
910 }
else if (
Previous.isOneOf(TT_ConditionalExpr, TT_CtorInitializerColon)) {
911 CurrentState.LastSpace = State.Column;
912 }
else if (
Previous.is(TT_BinaryOperator) &&
916 Current.StartsBinaryExpression)) {
920 CurrentState.LastSpace = State.Column;
921 }
else if (
Previous.is(TT_InheritanceColon)) {
922 CurrentState.Indent = State.Column;
923 CurrentState.LastSpace = State.Column;
924 }
else if (Current.is(TT_CSharpGenericTypeConstraintColon)) {
925 CurrentState.ColonPos = State.Column;
933 const FormatToken *Next =
Previous.MatchingParen->getNextNonComment();
934 if (Next && Next->isMemberAccess() && State.Stack.size() > 1 &&
935 State.Stack[State.Stack.size() - 2].CallContinuation == 0) {
936 CurrentState.LastSpace = State.Column;
942unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
944 FormatToken &Current = *State.NextToken;
945 assert(State.NextToken->Previous);
946 const FormatToken &
Previous = *State.NextToken->Previous;
947 auto &CurrentState = State.Stack.back();
951 unsigned Penalty = 0;
953 const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
954 const FormatToken *NextNonComment =
Previous.getNextNonComment();
956 NextNonComment = &Current;
959 if (!CurrentState.ContainsLineBreak)
961 CurrentState.ContainsLineBreak =
true;
963 Penalty += State.NextToken->SplitPenalty;
968 if (NextNonComment->is(tok::lessless) && CurrentState.FirstLessLess == 0 &&
970 CurrentState.BreakBeforeParameter)) {
974 State.Column = getNewLineColumn(State);
988 if (State.Column > State.FirstIndent) {
1003 if (Current.isNot(TT_TrailingReturnArrow) &&
1005 !PreviousNonComment || PreviousNonComment->isNot(tok::equal) ||
1007 CurrentState.NestedBlockIndent = State.Column;
1010 if (NextNonComment->isMemberAccess()) {
1011 if (CurrentState.CallContinuation == 0)
1012 CurrentState.CallContinuation = State.Column;
1013 }
else if (NextNonComment->is(TT_SelectorName)) {
1014 if (!CurrentState.ObjCSelectorNameFound) {
1015 if (NextNonComment->LongestObjCSelectorName == 0) {
1016 CurrentState.AlignColons =
false;
1018 CurrentState.ColonPos =
1020 ? std::max(CurrentState.Indent,
1022 : CurrentState.Indent) +
1024 NextNonComment->ColumnWidth);
1026 }
else if (CurrentState.AlignColons &&
1027 CurrentState.ColonPos <= NextNonComment->ColumnWidth) {
1028 CurrentState.ColonPos = State.Column + NextNonComment->ColumnWidth;
1030 }
else if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
1031 PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) {
1041 if (State.Stack.size() > 1) {
1042 State.Stack[State.Stack.size() - 2].LastSpace =
1043 std::max(CurrentState.LastSpace, CurrentState.Indent) +
1048 if ((PreviousNonComment &&
1049 PreviousNonComment->isOneOf(tok::comma, tok::semi) &&
1050 !CurrentState.AvoidBinPacking) ||
1052 CurrentState.BreakBeforeParameter =
false;
1054 if (PreviousNonComment &&
1055 (PreviousNonComment->isOneOf(TT_TemplateCloser, TT_JavaAnnotation) ||
1056 PreviousNonComment->ClosesRequiresClause) &&
1057 Current.NestingLevel == 0) {
1058 CurrentState.BreakBeforeParameter =
false;
1060 if (NextNonComment->is(tok::question) ||
1061 (PreviousNonComment && PreviousNonComment->is(tok::question))) {
1062 CurrentState.BreakBeforeParameter =
true;
1064 if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore)
1065 CurrentState.BreakBeforeParameter =
false;
1069 if (Current.is(tok::r_brace) && Current.MatchingParen &&
1072 !Current.MatchingParen->Children.empty()) {
1076 MaxEmptyLinesToKeep = 1;
1079 std::max(1u, std::min(Current.NewlinesBefore, MaxEmptyLinesToKeep));
1080 bool ContinuePPDirective =
1083 CurrentState.IsAligned, ContinuePPDirective);
1086 if (!Current.isTrailingComment())
1087 CurrentState.LastSpace = State.Column;
1088 if (Current.is(tok::lessless)) {
1092 CurrentState.LastSpace += 3;
1095 State.StartOfLineLevel = Current.NestingLevel;
1096 State.LowestLevelOnLine = Current.NestingLevel;
1100 bool NestedBlockSpecialCase =
1101 (!Style.
isCpp() && Current.is(tok::r_brace) && State.Stack.size() > 1 &&
1102 State.Stack[State.Stack.size() - 2].NestedBlockInlined) ||
1106 NestedBlockSpecialCase =
1107 NestedBlockSpecialCase ||
1108 (Current.MatchingParen &&
1109 Current.MatchingParen->is(TT_RequiresExpressionLBrace));
1110 if (!NestedBlockSpecialCase) {
1111 auto ParentLevelIt = std::next(State.Stack.rbegin());
1113 Current.MatchingParen && Current.MatchingParen->is(TT_LambdaLBrace)) {
1128 auto FindCurrentLevel = [&](
const auto &It) {
1129 return std::find_if(It, State.Stack.rend(), [](
const auto &PState) {
1130 return PState.Tok != nullptr;
1133 auto MaybeIncrement = [&](
const auto &It) {
1134 return It != State.Stack.rend() ? std::next(It) : It;
1136 auto LambdaLevelIt = FindCurrentLevel(State.Stack.rbegin());
1137 auto LevelContainingLambdaIt =
1138 FindCurrentLevel(MaybeIncrement(LambdaLevelIt));
1139 ParentLevelIt = MaybeIncrement(LevelContainingLambdaIt);
1141 for (
auto I = ParentLevelIt, E = State.Stack.rend(); I != E; ++I)
1142 I->BreakBeforeParameter =
true;
1145 if (PreviousNonComment &&
1146 !PreviousNonComment->isOneOf(tok::comma, tok::colon, tok::semi) &&
1147 ((PreviousNonComment->isNot(TT_TemplateCloser) &&
1148 !PreviousNonComment->ClosesRequiresClause) ||
1149 Current.NestingLevel != 0) &&
1150 !PreviousNonComment->isOneOf(
1151 TT_BinaryOperator, TT_FunctionAnnotationRParen, TT_JavaAnnotation,
1152 TT_LeadingJavaAnnotation) &&
1153 Current.isNot(TT_BinaryOperator) && !PreviousNonComment->opensScope() &&
1157 Current.isNot(TT_LambdaLBrace))) {
1158 CurrentState.BreakBeforeParameter =
true;
1163 if (PreviousNonComment &&
1164 (PreviousNonComment->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
1166 CurrentState.BreakBeforeClosingBrace =
true;
1169 if (PreviousNonComment && PreviousNonComment->is(tok::l_paren)) {
1170 CurrentState.BreakBeforeClosingParen =
1174 if (CurrentState.AvoidBinPacking) {
1179 bool PreviousIsBreakingCtorInitializerColon =
1180 PreviousNonComment && PreviousNonComment->is(TT_CtorInitializerColon) &&
1182 bool AllowAllConstructorInitializersOnNextLine =
1185 if (!(
Previous.isOneOf(tok::l_paren, tok::l_brace, TT_BinaryOperator) ||
1186 PreviousIsBreakingCtorInitializerColon) ||
1188 State.Line->MustBeDeclaration) ||
1190 !State.Line->MustBeDeclaration) ||
1191 (!AllowAllConstructorInitializersOnNextLine &&
1192 PreviousIsBreakingCtorInitializerColon) ||
1194 CurrentState.BreakBeforeParameter =
true;
1200 if (PreviousIsBreakingCtorInitializerColon &&
1201 AllowAllConstructorInitializersOnNextLine) {
1202 CurrentState.BreakBeforeParameter =
false;
1209unsigned ContinuationIndenter::getNewLineColumn(
const LineState &State) {
1210 if (!State.NextToken || !State.NextToken->Previous)
1213 FormatToken &Current = *State.NextToken;
1214 const auto &CurrentState = State.Stack.back();
1216 if (CurrentState.IsCSharpGenericTypeConstraint &&
1217 Current.isNot(TT_CSharpGenericTypeConstraint)) {
1218 return CurrentState.ColonPos + 2;
1221 const FormatToken &
Previous = *Current.Previous;
1223 unsigned ContinuationIndent =
1224 std::max(CurrentState.LastSpace, CurrentState.Indent) +
1226 const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
1227 const FormatToken *NextNonComment =
Previous.getNextNonComment();
1228 if (!NextNonComment)
1229 NextNonComment = &Current;
1234 return std::max(CurrentState.LastSpace,
1240 if (Style.
isVerilog() && PreviousNonComment &&
1242 return State.FirstIndent;
1246 State.Line->First->is(tok::kw_enum)) {
1247 return (Style.
IndentWidth * State.Line->First->IndentLevel) +
1251 if ((NextNonComment->is(tok::l_brace) && NextNonComment->is(
BK_Block)) ||
1253 if (Current.NestingLevel == 0 ||
1255 State.NextToken->is(TT_LambdaLBrace))) {
1256 return State.FirstIndent;
1258 return CurrentState.Indent;
1260 if ((Current.isOneOf(tok::r_brace, tok::r_square) ||
1262 State.Stack.size() > 1) {
1263 if (Current.closesBlockOrBlockTypeList(Style))
1264 return State.Stack[State.Stack.size() - 2].NestedBlockIndent;
1265 if (Current.MatchingParen && Current.MatchingParen->is(
BK_BracedInit))
1266 return State.Stack[State.Stack.size() - 2].LastSpace;
1267 return State.FirstIndent;
1284 if (Current.is(tok::r_paren) && State.Stack.size() > 1 &&
1286 Current.Next->isOneOf(tok::semi, tok::kw_const, tok::l_brace))) {
1287 return State.Stack[State.Stack.size() - 2].LastSpace;
1291 if (Style.
isTableGen() && Current.is(TT_TableGenDAGArgCloser) &&
1292 State.Stack.size() > 1) {
1293 return State.Stack[State.Stack.size() - 2].LastSpace;
1296 (Current.is(tok::r_paren) ||
1297 (Current.is(tok::r_brace) && Current.MatchingParen &&
1299 State.Stack.size() > 1) {
1300 return State.Stack[State.Stack.size() - 2].LastSpace;
1302 if (NextNonComment->is(TT_TemplateString) && NextNonComment->closesScope())
1303 return State.Stack[State.Stack.size() - 2].LastSpace;
1311 if (Current.is(tok::identifier) && Current.Next &&
1312 (!Style.
isVerilog() || Current.Next->is(tok::colon)) &&
1313 (Current.Next->is(TT_DictLiteral) ||
1314 (Style.
isProto() && Current.Next->isOneOf(tok::less, tok::l_brace)))) {
1315 return CurrentState.Indent;
1317 if (NextNonComment->is(TT_ObjCStringLiteral) &&
1318 State.StartOfStringLiteral != 0) {
1319 return State.StartOfStringLiteral - 1;
1321 if (NextNonComment->isStringLiteral() && State.StartOfStringLiteral != 0)
1322 return State.StartOfStringLiteral;
1323 if (NextNonComment->is(tok::lessless) && CurrentState.FirstLessLess != 0)
1324 return CurrentState.FirstLessLess;
1325 if (NextNonComment->isMemberAccess()) {
1326 if (CurrentState.CallContinuation == 0)
1327 return ContinuationIndent;
1328 return CurrentState.CallContinuation;
1330 if (CurrentState.QuestionColumn != 0 &&
1331 ((NextNonComment->is(tok::colon) &&
1332 NextNonComment->is(TT_ConditionalExpr)) ||
1333 Previous.is(TT_ConditionalExpr))) {
1334 if (((NextNonComment->is(tok::colon) && NextNonComment->Next &&
1335 !NextNonComment->Next->FakeLParens.empty() &&
1337 (
Previous.is(tok::colon) && !Current.FakeLParens.empty() &&
1339 !CurrentState.IsWrappedConditional) {
1344 unsigned Indent = CurrentState.Indent;
1351 return CurrentState.QuestionColumn;
1353 if (
Previous.is(tok::comma) && CurrentState.VariablePos != 0)
1354 return CurrentState.VariablePos;
1355 if (Current.is(TT_RequiresClause)) {
1361 return CurrentState.Indent;
1366 if (NextNonComment->isOneOf(TT_CtorInitializerColon, TT_InheritanceColon,
1367 TT_InheritanceComma)) {
1370 if ((PreviousNonComment &&
1371 (PreviousNonComment->ClosesTemplateDeclaration ||
1372 PreviousNonComment->ClosesRequiresClause ||
1373 (PreviousNonComment->is(TT_AttributeMacro) &&
1374 Current.isNot(tok::l_paren)) ||
1375 PreviousNonComment->isOneOf(
1376 TT_AttributeRParen, TT_AttributeSquare, TT_FunctionAnnotationRParen,
1377 TT_JavaAnnotation, TT_LeadingJavaAnnotation))) ||
1379 NextNonComment->isOneOf(tok::kw_operator, TT_FunctionDeclarationName))) {
1380 return std::max(CurrentState.LastSpace, CurrentState.Indent);
1382 if (NextNonComment->is(TT_SelectorName)) {
1383 if (!CurrentState.ObjCSelectorNameFound) {
1384 unsigned MinIndent = CurrentState.Indent;
1386 MinIndent = std::max(MinIndent,
1399 std::max(NextNonComment->LongestObjCSelectorName,
1400 NextNonComment->ColumnWidth) -
1401 NextNonComment->ColumnWidth;
1403 if (!CurrentState.AlignColons)
1404 return CurrentState.Indent;
1405 if (CurrentState.ColonPos > NextNonComment->ColumnWidth)
1406 return CurrentState.ColonPos - NextNonComment->ColumnWidth;
1407 return CurrentState.Indent;
1409 if (NextNonComment->is(tok::colon) && NextNonComment->is(TT_ObjCMethodExpr))
1410 return CurrentState.ColonPos;
1411 if (NextNonComment->is(TT_ArraySubscriptLSquare)) {
1412 if (CurrentState.StartOfArraySubscripts != 0) {
1413 return CurrentState.StartOfArraySubscripts;
1416 return CurrentState.Indent;
1418 return ContinuationIndent;
1423 if (State.Line->InPragmaDirective) {
1424 FormatToken *PragmaType = State.Line->First->Next->Next;
1425 if (PragmaType && PragmaType->TokenText ==
"omp")
1431 if (NextNonComment->is(tok::identifier) && NextNonComment->FakeRParens == 0 &&
1432 NextNonComment->Next && NextNonComment->Next->is(TT_ObjCMethodExpr)) {
1433 return CurrentState.Indent;
1436 if (NextNonComment->isOneOf(TT_StartOfName, TT_PointerOrReference) ||
1437 Previous.isOneOf(tok::coloncolon, tok::equal, TT_JsTypeColon)) {
1438 return ContinuationIndent;
1440 if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
1441 PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) {
1442 return ContinuationIndent;
1444 if (NextNonComment->is(TT_CtorInitializerComma))
1445 return CurrentState.Indent;
1446 if (PreviousNonComment && PreviousNonComment->is(TT_CtorInitializerColon) &&
1448 return CurrentState.Indent;
1450 if (PreviousNonComment && PreviousNonComment->is(TT_InheritanceColon) &&
1452 return CurrentState.Indent;
1455 Previous.isNot(TT_TableGenDAGArgOperatorToBreak) &&
1456 !Current.isBinaryOperator() &&
1457 !Current.isOneOf(tok::colon, tok::comment)) {
1458 return ContinuationIndent;
1460 if (Current.is(TT_ProtoExtensionLSquare))
1461 return CurrentState.Indent;
1462 if (Current.isBinaryOperator() && CurrentState.UnindentOperator) {
1463 return CurrentState.Indent - Current.Tok.getLength() -
1464 Current.SpacesRequiredBefore;
1466 if (Current.is(tok::comment) && NextNonComment->isBinaryOperator() &&
1467 CurrentState.UnindentOperator) {
1468 return CurrentState.Indent - NextNonComment->Tok.getLength() -
1469 NextNonComment->SpacesRequiredBefore;
1471 if (CurrentState.Indent == State.FirstIndent && PreviousNonComment &&
1472 !PreviousNonComment->isOneOf(tok::r_brace, TT_CtorInitializerComma)) {
1477 return CurrentState.Indent;
1492unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
1493 bool DryRun,
bool Newline) {
1494 assert(State.Stack.size());
1495 const FormatToken &Current = *State.NextToken;
1496 auto &CurrentState = State.Stack.back();
1498 if (Current.is(TT_CSharpGenericTypeConstraint))
1499 CurrentState.IsCSharpGenericTypeConstraint =
true;
1500 if (Current.isOneOf(tok::comma, TT_BinaryOperator))
1501 CurrentState.NoLineBreakInOperand =
false;
1502 if (Current.isOneOf(TT_InheritanceColon, TT_CSharpGenericTypeConstraintColon))
1503 CurrentState.AvoidBinPacking =
true;
1504 if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) {
1505 if (CurrentState.FirstLessLess == 0)
1506 CurrentState.FirstLessLess = State.Column;
1508 CurrentState.LastOperatorWrapped = Newline;
1510 if (Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless))
1511 CurrentState.LastOperatorWrapped = Newline;
1512 if (Current.is(TT_ConditionalExpr) && Current.Previous &&
1513 Current.Previous->isNot(TT_ConditionalExpr)) {
1514 CurrentState.LastOperatorWrapped = Newline;
1516 if (Current.is(TT_ArraySubscriptLSquare) &&
1517 CurrentState.StartOfArraySubscripts == 0) {
1518 CurrentState.StartOfArraySubscripts = State.Column;
1521 auto IsWrappedConditional = [](
const FormatToken &Tok) {
1522 if (!(Tok.is(TT_ConditionalExpr) && Tok.is(tok::question)))
1524 if (Tok.MustBreakBefore)
1527 const FormatToken *Next = Tok.getNextNonComment();
1528 return Next && Next->MustBreakBefore;
1530 if (IsWrappedConditional(Current))
1531 CurrentState.IsWrappedConditional =
true;
1533 CurrentState.QuestionColumn = State.Column;
1535 const FormatToken *
Previous = Current.Previous;
1539 CurrentState.QuestionColumn = State.Column;
1541 if (!Current.opensScope() && !Current.closesScope() &&
1542 Current.isNot(TT_PointerOrReference)) {
1543 State.LowestLevelOnLine =
1544 std::min(State.LowestLevelOnLine, Current.NestingLevel);
1546 if (Current.isMemberAccess())
1547 CurrentState.StartOfFunctionCall = !Current.NextOperator ? 0 : State.Column;
1548 if (Current.is(TT_SelectorName))
1549 CurrentState.ObjCSelectorNameFound =
true;
1550 if (Current.is(TT_CtorInitializerColon) &&
1561 CurrentState.NestedBlockIndent = CurrentState.Indent;
1563 CurrentState.AvoidBinPacking =
true;
1564 CurrentState.BreakBeforeParameter =
1569 CurrentState.BreakBeforeParameter =
false;
1572 if (Current.is(TT_CtorInitializerColon) &&
1574 CurrentState.Indent =
1576 CurrentState.NestedBlockIndent = CurrentState.Indent;
1578 CurrentState.AvoidBinPacking =
true;
1580 CurrentState.BreakBeforeParameter =
false;
1582 if (Current.is(TT_InheritanceColon)) {
1583 CurrentState.Indent =
1586 if (Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline)
1587 CurrentState.NestedBlockIndent = State.Column + Current.ColumnWidth + 1;
1588 if (Current.isOneOf(TT_LambdaLSquare, TT_TrailingReturnArrow))
1589 CurrentState.LastSpace = State.Column;
1590 if (Current.is(TT_RequiresExpression) &&
1592 CurrentState.NestedBlockIndent = State.Column;
1596 const FormatToken *
Previous = Current.getPreviousNonComment();
1604 if (Current.isNot(tok::comment) && !Current.ClosesRequiresClause &&
1606 Previous->isNot(TT_DictLiteral) && State.Stack.size() > 1 &&
1607 !CurrentState.HasMultipleNestedBlocks) {
1608 if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline)
1609 for (ParenState &PState : llvm::drop_end(State.Stack))
1610 PState.NoLineBreak =
true;
1611 State.Stack[State.Stack.size() - 2].NestedBlockInlined =
false;
1613 if (
Previous && (
Previous->isOneOf(TT_BinaryOperator, TT_ConditionalExpr) ||
1614 (
Previous->isOneOf(tok::l_paren, tok::comma, tok::colon) &&
1615 !
Previous->isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)))) {
1616 CurrentState.NestedBlockInlined =
1620 moveStatePastFakeLParens(State, Newline);
1621 moveStatePastScopeCloser(State);
1624 bool AllowBreak = !State.Stack.back().NoLineBreak &&
1625 !State.Stack.back().NoLineBreakInOperand;
1626 moveStatePastScopeOpener(State, Newline);
1627 moveStatePastFakeRParens(State);
1629 if (Current.is(TT_ObjCStringLiteral) && State.StartOfStringLiteral == 0)
1630 State.StartOfStringLiteral = State.Column + 1;
1631 if (Current.is(TT_CSharpStringLiteral) && State.StartOfStringLiteral == 0) {
1632 State.StartOfStringLiteral = State.Column + 1;
1633 }
else if (Current.is(TT_TableGenMultiLineString) &&
1634 State.StartOfStringLiteral == 0) {
1635 State.StartOfStringLiteral = State.Column + 1;
1636 }
else if (Current.isStringLiteral() && State.StartOfStringLiteral == 0) {
1637 State.StartOfStringLiteral = State.Column;
1638 }
else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) &&
1639 !Current.isStringLiteral()) {
1640 State.StartOfStringLiteral = 0;
1643 State.Column += Current.ColumnWidth;
1644 State.NextToken = State.NextToken->Next;
1649 if (Style.
isVerilog() && State.NextToken &&
1650 State.NextToken->MustBreakBefore &&
1653 CurrentState.Indent = State.FirstIndent;
1657 handleEndOfLine(Current, State, DryRun, AllowBreak, Newline);
1660 Current.Role->formatFromToken(State,
this, DryRun);
1667 Penalty +=
Previous->Role->formatAfterToken(State,
this, DryRun);
1672void ContinuationIndenter::moveStatePastFakeLParens(LineState &State,
1674 const FormatToken &Current = *State.NextToken;
1675 if (Current.FakeLParens.empty())
1678 const FormatToken *
Previous = Current.getPreviousNonComment();
1683 bool SkipFirstExtraIndent =
1686 Previous->isOneOf(tok::semi, tok::kw_return, TT_RequiresClause) ||
1690 for (
const auto &PrecedenceLevel : llvm::reverse(Current.FakeLParens)) {
1691 const auto &CurrentState = State.Stack.back();
1692 ParenState NewParenState = CurrentState;
1693 NewParenState.Tok =
nullptr;
1694 NewParenState.ContainsLineBreak =
false;
1695 NewParenState.LastOperatorWrapped =
true;
1696 NewParenState.IsChainedConditional =
false;
1697 NewParenState.IsWrappedConditional =
false;
1698 NewParenState.UnindentOperator =
false;
1699 NewParenState.NoLineBreak =
1700 NewParenState.NoLineBreak || CurrentState.NoLineBreakInOperand;
1704 NewParenState.AvoidBinPacking =
false;
1709 if (!Current.isTrailingComment() &&
1715 PrecedenceLevel !=
prec::Comma || Current.NestingLevel == 0) &&
1718 TT_TableGenDAGArgListCommaToBreak)))) {
1719 NewParenState.Indent = std::max(
1720 std::max(State.Column, NewParenState.Indent), CurrentState.LastSpace);
1727 State.Stack.size() > 1) {
1728 NewParenState.Indent = State.Stack[State.Stack.size() - 2].Indent +
1740 NewParenState.UnindentOperator =
true;
1743 NewParenState.IsAligned =
true;
1753 NewParenState.LastSpace = std::max(NewParenState.LastSpace, State.Column);
1755 Current.isNot(TT_UnaryOperator) &&
1757 NewParenState.StartOfFunctionCall = State.Column;
1767 &PrecedenceLevel == &Current.FakeLParens.back() &&
1768 !CurrentState.IsWrappedConditional) {
1769 NewParenState.IsChainedConditional =
true;
1770 NewParenState.UnindentOperator = State.Stack.back().UnindentOperator;
1773 !Current.isTrailingComment())) {
1777 NewParenState.BreakBeforeParameter =
false;
1778 State.Stack.push_back(NewParenState);
1779 SkipFirstExtraIndent =
false;
1783void ContinuationIndenter::moveStatePastFakeRParens(LineState &State) {
1784 for (
unsigned i = 0, e = State.NextToken->FakeRParens; i != e; ++i) {
1785 unsigned VariablePos = State.Stack.back().VariablePos;
1786 if (State.Stack.size() == 1) {
1790 State.Stack.pop_back();
1791 State.Stack.back().VariablePos = VariablePos;
1797 State.Stack.back().LastSpace -= Style.
IndentWidth;
1801void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
1803 const FormatToken &Current = *State.NextToken;
1804 if (!Current.opensScope())
1807 const auto &CurrentState = State.Stack.back();
1810 if (Current.isOneOf(tok::less, tok::l_paren) &&
1811 CurrentState.IsCSharpGenericTypeConstraint) {
1815 if (Current.MatchingParen && Current.is(
BK_Block)) {
1816 moveStateToNewBlock(State, Newline);
1821 unsigned LastSpace = CurrentState.LastSpace;
1822 bool AvoidBinPacking;
1823 bool BreakBeforeParameter =
false;
1824 unsigned NestedBlockIndent = std::max(CurrentState.StartOfFunctionCall,
1825 CurrentState.NestedBlockIndent);
1826 if (Current.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
1828 if (Current.opensBlockOrBlockTypeList(Style)) {
1830 std::min(State.Column, CurrentState.NestedBlockIndent);
1831 }
else if (Current.is(tok::l_brace)) {
1838 const FormatToken *NextNonComment = Current.getNextNonComment();
1839 bool EndsInComma = Current.MatchingParen &&
1840 Current.MatchingParen->Previous &&
1841 Current.MatchingParen->Previous->is(tok::comma);
1842 AvoidBinPacking = EndsInComma || Current.is(TT_DictLiteral) ||
1844 (NextNonComment && NextNonComment->isOneOf(
1845 TT_DesignatedInitializerPeriod,
1846 TT_DesignatedInitializerLSquare));
1847 BreakBeforeParameter = EndsInComma;
1848 if (Current.ParameterCount > 1)
1849 NestedBlockIndent = std::max(NestedBlockIndent, State.Column + 1);
1853 std::max(CurrentState.LastSpace, CurrentState.StartOfFunctionCall);
1855 if (Style.
isTableGen() && Current.is(TT_TableGenDAGArgOpenerToBreak) &&
1861 const FormatToken *Next = Current.Next;
1862 if (Next && Next->is(TT_TableGenDAGArgOperatorID))
1863 NewIndent = State.Column + Next->TokenText.size() + 2;
1870 if (Current.is(tok::less) && Current.ParentBracket == tok::l_paren) {
1871 NewIndent = std::max(NewIndent, CurrentState.Indent);
1872 LastSpace = std::max(LastSpace, CurrentState.Indent);
1876 Current.MatchingParen &&
1877 Current.MatchingParen->getPreviousNonComment() &&
1878 Current.MatchingParen->getPreviousNonComment()->is(tok::comma);
1882 bool ObjCBinPackProtocolList =
1887 bool BinPackDeclaration =
1889 (State.Line->Type ==
LT_ObjCDecl && ObjCBinPackProtocolList);
1891 bool GenericSelection =
1892 Current.getPreviousNonComment() &&
1893 Current.getPreviousNonComment()->is(tok::kw__Generic);
1896 (CurrentState.IsCSharpGenericTypeConstraint) || GenericSelection ||
1898 (State.Line->MustBeDeclaration && !BinPackDeclaration) ||
1904 if (Current.is(TT_ObjCMethodExpr) && Current.MatchingParen &&
1911 BreakBeforeParameter =
true;
1916 for (
const FormatToken *Tok = &Current;
1917 Tok && Tok != Current.MatchingParen; Tok = Tok->Next) {
1918 if (Tok->MustBreakBefore ||
1919 (Tok->CanBreakBefore && Tok->NewlinesBefore > 0)) {
1920 BreakBeforeParameter =
true;
1928 BreakBeforeParameter =
true;
1934 Current.Children.empty() &&
1935 !Current.isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) &&
1936 (CurrentState.NoLineBreak || CurrentState.NoLineBreakInOperand ||
1937 (Current.is(TT_TemplateOpener) &&
1938 CurrentState.ContainsUnwrappedBuilder));
1939 State.Stack.push_back(
1940 ParenState(&Current, NewIndent, LastSpace, AvoidBinPacking, NoLineBreak));
1941 auto &NewState = State.Stack.back();
1942 NewState.NestedBlockIndent = NestedBlockIndent;
1943 NewState.BreakBeforeParameter = BreakBeforeParameter;
1944 NewState.HasMultipleNestedBlocks = (Current.BlockParameterCount > 1);
1947 Current.is(tok::l_paren)) {
1949 FormatToken
const *next = Current.Next;
1951 if (next->is(TT_LambdaLSquare)) {
1952 NewState.HasMultipleNestedBlocks =
true;
1959 NewState.IsInsideObjCArrayLiteral = Current.is(TT_ArrayInitializerLSquare) &&
1961 Current.Previous->is(tok::at);
1964void ContinuationIndenter::moveStatePastScopeCloser(LineState &State) {
1965 const FormatToken &Current = *State.NextToken;
1966 if (!Current.closesScope())
1971 if (State.Stack.size() > 1 &&
1972 (Current.isOneOf(tok::r_paren, tok::r_square, TT_TemplateString) ||
1973 (Current.is(tok::r_brace) && State.NextToken != State.Line->First) ||
1974 State.NextToken->is(TT_TemplateCloser) ||
1975 State.NextToken->is(TT_TableGenListCloser) ||
1976 (Current.is(tok::greater) && Current.is(TT_DictLiteral)))) {
1977 State.Stack.pop_back();
1980 auto &CurrentState = State.Stack.back();
1992 if (CurrentState.BreakBeforeParameter && Current.MatchingParen &&
1993 Current.MatchingParen->Previous) {
1994 const FormatToken &CurrentScopeOpener = *Current.MatchingParen->Previous;
1995 if (CurrentScopeOpener.is(TT_ObjCMethodExpr) &&
1996 CurrentScopeOpener.MatchingParen) {
1997 int NecessarySpaceInLine =
1999 CurrentScopeOpener.TotalLength - Current.TotalLength - 1;
2000 if (State.Column + Current.ColumnWidth + NecessarySpaceInLine <=
2002 CurrentState.BreakBeforeParameter =
false;
2007 if (Current.is(tok::r_square)) {
2009 const FormatToken *NextNonComment = Current.getNextNonComment();
2010 if (NextNonComment && NextNonComment->isNot(tok::l_square))
2011 CurrentState.StartOfArraySubscripts = 0;
2015void ContinuationIndenter::moveStateToNewBlock(LineState &State,
bool NewLine) {
2017 State.NextToken->is(TT_LambdaLBrace) &&
2018 !State.Line->MightBeFunctionDecl) {
2019 State.Stack.back().NestedBlockIndent = State.FirstIndent;
2021 unsigned NestedBlockIndent = State.Stack.back().NestedBlockIndent;
2023 unsigned NewIndent =
2024 NestedBlockIndent + (State.NextToken->is(TT_ObjCBlockLBrace)
2034 State.NextToken->is(TT_LambdaLBrace);
2036 State.Stack.push_back(ParenState(State.NextToken, NewIndent,
2037 State.Stack.back().LastSpace,
2038 true, NoLineBreak));
2039 State.Stack.back().NestedBlockIndent = NestedBlockIndent;
2040 State.Stack.back().BreakBeforeParameter =
true;
2046 size_t LastNewlinePos =
Text.find_last_of(
"\n");
2047 if (LastNewlinePos == StringRef::npos) {
2048 return StartColumn +
2052 0, TabWidth, Encoding);
2056unsigned ContinuationIndenter::reformatRawStringLiteral(
2057 const FormatToken &Current, LineState &State,
2058 const FormatStyle &RawStringStyle,
bool DryRun,
bool Newline) {
2059 unsigned StartColumn = State.Column - Current.ColumnWidth;
2061 StringRef NewDelimiter =
2063 if (NewDelimiter.empty())
2064 NewDelimiter = OldDelimiter;
2067 unsigned OldPrefixSize = 3 + OldDelimiter.size();
2068 unsigned OldSuffixSize = 2 + OldDelimiter.size();
2071 std::string RawText = std::string(
2072 Current.TokenText.substr(OldPrefixSize).drop_back(OldSuffixSize));
2073 if (NewDelimiter != OldDelimiter) {
2076 std::string CanonicalDelimiterSuffix = (
")" + NewDelimiter +
"\"").str();
2077 if (StringRef(RawText).contains(CanonicalDelimiterSuffix))
2078 NewDelimiter = OldDelimiter;
2081 unsigned NewPrefixSize = 3 + NewDelimiter.size();
2082 unsigned NewSuffixSize = 2 + NewDelimiter.size();
2085 unsigned FirstStartColumn = StartColumn + NewPrefixSize;
2096 bool ContentStartsOnNewline = Current.TokenText[OldPrefixSize] ==
'\n';
2118 unsigned CurrentIndent =
2119 (!Newline && Current.Next && Current.Next->is(tok::r_paren))
2120 ? State.Stack.back().NestedBlockIndent
2121 : State.Stack.back().Indent;
2122 unsigned NextStartColumn = ContentStartsOnNewline
2134 unsigned LastStartColumn =
2135 Current.NewlinesBefore ? FirstStartColumn - NewPrefixSize : CurrentIndent;
2138 RawStringStyle, RawText, {tooling::Range(0, RawText.size())},
2139 FirstStartColumn, NextStartColumn, LastStartColumn,
"<stdin>",
2143 tooling::Replacements NoFixes;
2145 return addMultilineToken(Current, State);
2147 if (NewDelimiter != OldDelimiter) {
2150 SourceLocation PrefixDelimiterStart =
2151 Current.Tok.getLocation().getLocWithOffset(2);
2152 auto PrefixErr = Whitespaces.
addReplacement(tooling::Replacement(
2153 SourceMgr, PrefixDelimiterStart, OldDelimiter.size(), NewDelimiter));
2156 <<
"Failed to update the prefix delimiter of a raw string: "
2157 << llvm::toString(std::move(PrefixErr)) <<
"\n";
2161 SourceLocation SuffixDelimiterStart =
2162 Current.Tok.getLocation().getLocWithOffset(Current.TokenText.size() -
2163 1 - OldDelimiter.size());
2164 auto SuffixErr = Whitespaces.
addReplacement(tooling::Replacement(
2165 SourceMgr, SuffixDelimiterStart, OldDelimiter.size(), NewDelimiter));
2168 <<
"Failed to update the suffix delimiter of a raw string: "
2169 << llvm::toString(std::move(SuffixErr)) <<
"\n";
2172 SourceLocation OriginLoc =
2173 Current.Tok.getLocation().getLocWithOffset(OldPrefixSize);
2174 for (
const tooling::Replacement &Fix : Fixes.first) {
2176 SourceMgr, OriginLoc.getLocWithOffset(Fix.getOffset()),
2177 Fix.getLength(), Fix.getReplacementText()));
2179 llvm::errs() <<
"Failed to reformat raw string: "
2180 << llvm::toString(std::move(Err)) <<
"\n";
2185 *NewCode, FirstStartColumn, Style.
TabWidth, Encoding);
2186 State.Column = RawLastLineEndColumn + NewSuffixSize;
2190 unsigned PrefixExcessCharacters =
2195 ContentStartsOnNewline || (NewCode->find(
'\n') != std::string::npos);
2198 for (ParenState &
Paren : State.Stack)
2199 Paren.BreakBeforeParameter =
true;
2204unsigned ContinuationIndenter::addMultilineToken(
const FormatToken &Current,
2207 for (ParenState &
Paren : State.Stack)
2208 Paren.BreakBeforeParameter =
true;
2210 unsigned ColumnsUsed = State.Column;
2213 State.Column = Current.LastLineColumnWidth;
2220unsigned ContinuationIndenter::handleEndOfLine(
const FormatToken &Current,
2221 LineState &State,
bool DryRun,
2222 bool AllowBreak,
bool Newline) {
2223 unsigned Penalty = 0;
2226 auto RawStringStyle = getRawStringStyle(Current, State);
2227 if (RawStringStyle && !Current.Finalized) {
2228 Penalty = reformatRawStringLiteral(Current, State, *RawStringStyle, DryRun,
2230 }
else if (Current.IsMultiline && Current.isNot(TT_BlockComment)) {
2233 Penalty = addMultilineToken(Current, State);
2236 LineState OriginalState = State;
2240 bool Strict =
false;
2243 bool Exceeded =
false;
2244 std::tie(Penalty, Exceeded) = breakProtrudingToken(
2245 Current, State, AllowBreak,
true, Strict);
2249 LineState StrictState = OriginalState;
2250 unsigned StrictPenalty =
2251 breakProtrudingToken(Current, StrictState, AllowBreak,
2254 Strict = StrictPenalty <= Penalty;
2256 Penalty = StrictPenalty;
2257 State = StrictState;
2263 breakProtrudingToken(Current, OriginalState, AllowBreak,
false,
2268 unsigned ExcessCharacters = State.Column -
getColumnLimit(State);
2279 if (!Tok || Tok->isNot(tok::l_paren))
2284 if (Tok->is(TT_TemplateCloser)) {
2289 if (!Tok || Tok->isNot(tok::identifier))
2294std::optional<FormatStyle>
2295ContinuationIndenter::getRawStringStyle(
const FormatToken &Current,
2296 const LineState &State) {
2297 if (!Current.isStringLiteral())
2298 return std::nullopt;
2301 return std::nullopt;
2303 if (!RawStringStyle && Delimiter->empty()) {
2307 if (!RawStringStyle)
2308 return std::nullopt;
2310 return RawStringStyle;
2313std::unique_ptr<BreakableToken>
2314ContinuationIndenter::createBreakableToken(
const FormatToken &Current,
2315 LineState &State,
bool AllowBreak) {
2316 unsigned StartColumn = State.Column - Current.ColumnWidth;
2317 if (Current.isStringLiteral()) {
2334 if (Current.IsUnterminatedLiteral)
2338 if (State.Stack.back().IsInsideObjCArrayLiteral)
2345 if (Style.
isVerilog() && Current.Previous &&
2346 Current.Previous->isOneOf(tok::kw_export, Keywords.
kw_import)) {
2349 StringRef
Text = Current.TokenText;
2355 unsigned UnbreakableTailLength = (State.NextToken &&
canBreak(State))
2357 : Current.UnbreakableTailLength;
2363 Text.ends_with(
"'")) {
2365 }
else if (Style.
isCSharp() &&
Text.starts_with(
"@\"") &&
2366 Text.ends_with(
"\"")) {
2368 }
else if (
Text.starts_with(
"\"") &&
Text.ends_with(
"\"")) {
2373 return std::make_unique<BreakableStringLiteralUsingOperators>(
2374 Current, QuoteStyle,
2376 UnbreakableTailLength, State.Line->InPPDirective, Encoding, Style);
2385 if ((
Text.ends_with(Postfix =
"\"") &&
2386 (
Text.starts_with(Prefix =
"@\"") ||
Text.starts_with(Prefix =
"\"") ||
2387 Text.starts_with(Prefix =
"u\"") ||
2388 Text.starts_with(Prefix =
"U\"") ||
2389 Text.starts_with(Prefix =
"u8\"") ||
2390 Text.starts_with(Prefix =
"L\""))) ||
2391 (
Text.starts_with(Prefix =
"_T(\"") &&
2392 Text.ends_with(Postfix =
"\")"))) {
2393 return std::make_unique<BreakableStringLiteral>(
2394 Current, StartColumn, Prefix, Postfix, UnbreakableTailLength,
2395 State.Line->InPPDirective, Encoding, Style);
2397 }
else if (Current.is(TT_BlockComment)) {
2405 return std::make_unique<BreakableBlockComment>(
2406 Current, StartColumn, Current.OriginalColumn, !Current.Previous,
2407 State.Line->InPPDirective, Encoding, Style, Whitespaces.
useCRLF());
2408 }
else if (Current.is(TT_LineComment) &&
2409 (!Current.Previous ||
2410 Current.Previous->isNot(TT_ImplicitStringLiteral))) {
2411 bool RegularComments = [&]() {
2412 for (
const FormatToken *
T = &Current;
T &&
T->is(TT_LineComment);
2414 if (!(
T->TokenText.starts_with(
"//") ||
T->TokenText.starts_with(
"#")))
2420 CommentPragmasRegex.match(Current.TokenText.substr(2)) ||
2424 return std::make_unique<BreakableLineCommentSection>(
2425 Current, StartColumn,
false, Encoding, Style);
2430std::pair<unsigned, bool>
2431ContinuationIndenter::breakProtrudingToken(
const FormatToken &Current,
2432 LineState &State,
bool AllowBreak,
2433 bool DryRun,
bool Strict) {
2434 std::unique_ptr<const BreakableToken> Token =
2435 createBreakableToken(Current, State, AllowBreak);
2438 assert(Token->getLineCount() > 0);
2440 if (Current.is(TT_LineComment)) {
2444 if (ColumnLimit == 0) {
2447 ColumnLimit = std::numeric_limits<
decltype(ColumnLimit)>
::max();
2449 if (Current.UnbreakableTailLength >= ColumnLimit)
2453 unsigned StartColumn = State.Column - Current.ColumnWidth;
2454 unsigned NewBreakPenalty = Current.isStringLiteral()
2459 bool Exceeded =
false;
2461 bool BreakInserted = Token->introducesBreakBeforeToken();
2464 bool NewBreakBefore =
false;
2468 bool Reflow =
false;
2471 unsigned TailOffset = 0;
2473 unsigned ContentStartColumn =
2474 Token->getContentStartColumn(0,
false);
2476 unsigned RemainingTokenColumns =
2477 Token->getRemainingLength(0, TailOffset, ContentStartColumn);
2480 Token->adaptStartOfLine(0, Whitespaces);
2482 unsigned ContentIndent = 0;
2483 unsigned Penalty = 0;
2484 LLVM_DEBUG(llvm::dbgs() <<
"Breaking protruding token at column "
2485 << StartColumn <<
".\n");
2486 for (
unsigned LineIndex = 0, EndIndex = Token->getLineCount();
2487 LineIndex != EndIndex; ++LineIndex) {
2488 LLVM_DEBUG(llvm::dbgs()
2489 <<
" Line: " << LineIndex <<
" (Reflow: " << Reflow <<
")\n");
2490 NewBreakBefore =
false;
2494 bool TryReflow = Reflow;
2496 while (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
2497 LLVM_DEBUG(llvm::dbgs() <<
" Over limit, need: "
2498 << (ContentStartColumn + RemainingTokenColumns)
2499 <<
", space: " << ColumnLimit
2500 <<
", reflown prefix: " << ContentStartColumn
2501 <<
", offset in line: " << TailOffset <<
"\n");
2507 Token->getSplit(LineIndex, TailOffset, ColumnLimit,
2508 ContentStartColumn, CommentPragmasRegex);
2509 if (
Split.first == StringRef::npos) {
2512 if (LineIndex < EndIndex - 1) {
2516 (ContentStartColumn + RemainingTokenColumns - ColumnLimit);
2518 LLVM_DEBUG(llvm::dbgs() <<
" No break opportunity.\n");
2521 assert(
Split.first != 0);
2523 if (Token->supportsReflow()) {
2543 unsigned ToSplitColumns = Token->getRangeLength(
2544 LineIndex, TailOffset,
Split.first, ContentStartColumn);
2545 LLVM_DEBUG(llvm::dbgs() <<
" ToSplit: " << ToSplitColumns <<
"\n");
2548 LineIndex, TailOffset +
Split.first +
Split.second, ColumnLimit,
2549 ContentStartColumn + ToSplitColumns + 1, CommentPragmasRegex);
2552 unsigned ToNextSplitColumns = 0;
2553 if (NextSplit.first == StringRef::npos) {
2554 ToNextSplitColumns = Token->getRemainingLength(LineIndex, TailOffset,
2555 ContentStartColumn);
2557 ToNextSplitColumns = Token->getRangeLength(
2558 LineIndex, TailOffset,
2559 Split.first +
Split.second + NextSplit.first, ContentStartColumn);
2563 ToNextSplitColumns =
2564 Token->getLengthAfterCompression(ToNextSplitColumns, Split);
2565 LLVM_DEBUG(llvm::dbgs()
2566 <<
" ContentStartColumn: " << ContentStartColumn <<
"\n");
2567 LLVM_DEBUG(llvm::dbgs()
2568 <<
" ToNextSplit: " << ToNextSplitColumns <<
"\n");
2571 bool ContinueOnLine =
2572 ContentStartColumn + ToNextSplitColumns <= ColumnLimit;
2573 unsigned ExcessCharactersPenalty = 0;
2574 if (!ContinueOnLine && !Strict) {
2577 ExcessCharactersPenalty =
2578 (ContentStartColumn + ToNextSplitColumns - ColumnLimit) *
2580 LLVM_DEBUG(llvm::dbgs()
2581 <<
" Penalty excess: " << ExcessCharactersPenalty
2582 <<
"\n break : " << NewBreakPenalty <<
"\n");
2583 if (ExcessCharactersPenalty < NewBreakPenalty) {
2585 ContinueOnLine =
true;
2588 if (ContinueOnLine) {
2589 LLVM_DEBUG(llvm::dbgs() <<
" Continuing on line...\n");
2594 Token->compressWhitespace(LineIndex, TailOffset, Split,
2598 ContentStartColumn += ToSplitColumns + 1;
2599 Penalty += ExcessCharactersPenalty;
2601 RemainingTokenColumns = Token->getRemainingLength(
2602 LineIndex, TailOffset, ContentStartColumn);
2606 LLVM_DEBUG(llvm::dbgs() <<
" Breaking...\n");
2611 ContentIndent = Token->getContentIndent(LineIndex);
2612 LLVM_DEBUG(llvm::dbgs()
2613 <<
" ContentIndent: " << ContentIndent <<
"\n");
2614 ContentStartColumn = ContentIndent + Token->getContentStartColumn(
2617 unsigned NewRemainingTokenColumns = Token->getRemainingLength(
2618 LineIndex, TailOffset +
Split.first +
Split.second,
2619 ContentStartColumn);
2620 if (NewRemainingTokenColumns == 0) {
2623 ContentStartColumn =
2624 Token->getContentStartColumn(LineIndex,
true);
2625 NewRemainingTokenColumns = Token->getRemainingLength(
2626 LineIndex, TailOffset +
Split.first +
Split.second,
2627 ContentStartColumn);
2633 if (NewRemainingTokenColumns >= RemainingTokenColumns) {
2638 LLVM_DEBUG(llvm::dbgs() <<
" Breaking at: " << TailOffset +
Split.first
2639 <<
", " <<
Split.second <<
"\n");
2641 Token->insertBreak(LineIndex, TailOffset, Split, ContentIndent,
2645 Penalty += NewBreakPenalty;
2647 RemainingTokenColumns = NewRemainingTokenColumns;
2648 BreakInserted =
true;
2649 NewBreakBefore =
true;
2653 if (LineIndex + 1 != EndIndex) {
2654 unsigned NextLineIndex = LineIndex + 1;
2655 if (NewBreakBefore) {
2674 ContentStartColumn += RemainingTokenColumns + 1;
2679 Token->getReflowSplit(NextLineIndex, CommentPragmasRegex);
2680 LLVM_DEBUG(llvm::dbgs()
2681 <<
" Size of reflown text: " << ContentStartColumn
2682 <<
"\n Potential reflow split: ");
2683 if (SplitBeforeNext.first != StringRef::npos) {
2684 LLVM_DEBUG(llvm::dbgs() << SplitBeforeNext.first <<
", "
2685 << SplitBeforeNext.second <<
"\n");
2686 TailOffset = SplitBeforeNext.first + SplitBeforeNext.second;
2689 RemainingTokenColumns = Token->getRemainingLength(
2690 NextLineIndex, TailOffset, ContentStartColumn);
2692 if (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
2693 LLVM_DEBUG(llvm::dbgs()
2694 <<
" Over limit after reflow, need: "
2695 << (ContentStartColumn + RemainingTokenColumns)
2696 <<
", space: " << ColumnLimit
2697 <<
", reflown prefix: " << ContentStartColumn
2698 <<
", offset in line: " << TailOffset <<
"\n");
2704 Token->getSplit(NextLineIndex, TailOffset, ColumnLimit,
2705 ContentStartColumn, CommentPragmasRegex);
2706 if (
Split.first == StringRef::npos) {
2707 LLVM_DEBUG(llvm::dbgs() <<
" Did not find later break\n");
2713 unsigned ToSplitColumns = Token->getRangeLength(
2714 NextLineIndex, TailOffset,
Split.first, ContentStartColumn);
2715 if (ContentStartColumn + ToSplitColumns > ColumnLimit) {
2716 LLVM_DEBUG(llvm::dbgs() <<
" Next split protrudes, need: "
2717 << (ContentStartColumn + ToSplitColumns)
2718 <<
", space: " << ColumnLimit);
2719 unsigned ExcessCharactersPenalty =
2720 (ContentStartColumn + ToSplitColumns - ColumnLimit) *
2722 if (NewBreakPenalty < ExcessCharactersPenalty)
2728 LLVM_DEBUG(llvm::dbgs() <<
"not found.\n");
2736 ContentStartColumn =
2737 Token->getContentStartColumn(NextLineIndex,
false);
2738 RemainingTokenColumns = Token->getRemainingLength(
2739 NextLineIndex, TailOffset, ContentStartColumn);
2742 Token->adaptStartOfLine(NextLineIndex, Whitespaces);
2757 if (NewBreakBefore) {
2758 assert(Penalty >= NewBreakPenalty);
2759 Penalty -= NewBreakPenalty;
2762 Token->reflow(NextLineIndex, Whitespaces);
2768 Token->getSplitAfterLastLine(TailOffset);
2769 if (SplitAfterLastLine.first != StringRef::npos) {
2770 LLVM_DEBUG(llvm::dbgs() <<
"Replacing whitespace after last line.\n");
2775 (ContentStartColumn + RemainingTokenColumns - ColumnLimit);
2778 Token->replaceWhitespaceAfterLastLine(TailOffset, SplitAfterLastLine,
2781 ContentStartColumn =
2782 Token->getContentStartColumn(Token->getLineCount() - 1,
true);
2783 RemainingTokenColumns = Token->getRemainingLength(
2784 Token->getLineCount() - 1,
2785 TailOffset + SplitAfterLastLine.first + SplitAfterLastLine.second,
2786 ContentStartColumn);
2789 State.Column = ContentStartColumn + RemainingTokenColumns -
2790 Current.UnbreakableTailLength;
2792 if (BreakInserted) {
2794 Token->updateAfterBroken(Whitespaces);
2799 if (Current.isNot(TT_LineComment))
2800 for (ParenState &
Paren : State.Stack)
2801 Paren.BreakBeforeParameter =
true;
2803 if (Current.is(TT_BlockComment))
2804 State.NoContinuation =
true;
2806 State.Stack.back().LastSpace = StartColumn;
2809 Token->updateNextToken(State);
2811 return {Penalty, Exceeded};
2816 return Style.
ColumnLimit - (State.Line->InPPDirective ? 2 : 0);
2819bool ContinuationIndenter::nextIsMultilineString(
const LineState &State) {
2821 if (!Current.isStringLiteral() || Current.is(TT_ImplicitStringLiteral))
2826 if (Current.TokenText.starts_with(
"R\""))
2828 if (Current.IsMultiline)
2830 if (Current.getNextNonComment() &&
2831 Current.getNextNonComment()->isStringLiteral()) {
2835 State.Column + Current.ColumnWidth + Current.UnbreakableTailLength >
Declares BreakableToken, BreakableStringLiteral, BreakableComment, BreakableBlockComment and Breakabl...
This file implements an indenter that manages the indentation of continuations.
Defines and computes precedence levels for binary/ternary operators.
Defines the SourceManager interface.
unsigned LongestObjCSelectorName
Defines the clang::TokenKind enum and support functions.
WhitespaceManager class manages whitespace around tokens and their replacements.
__DEVICE__ int max(int __a, int __b)
This class handles loading and caching of source files into memory.
unsigned getSpellingColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const
The JSON file list parser is used to communicate input to InstallAPI.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
Language
The language for the input, used to select and validate the language standard and possible actions.
const FunctionProtoType * T