21 #include "llvm/Support/Debug.h" 23 #define DEBUG_TYPE "format-indenter" 38 const std::vector<ParenState> &Stack) {
81 int MatchingStackIndex = Stack.size() - 1;
87 while (MatchingStackIndex >= 0 && Stack[MatchingStackIndex].Tok != LBrace)
89 return MatchingStackIndex >= 0 ? &Stack[MatchingStackIndex] :
nullptr;
98 tok::l_brace, TT_ArrayInitializerLSquare, tok::less)) {
123 if (Current.
is(TT_CtorInitializerComma) &&
124 Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma)
126 if (Style.Language == FormatStyle::LK_Proto && Current.
is(TT_SelectorName))
129 ((Previous.
isNot(TT_CtorInitializerComma) ||
130 Style.BreakConstructorInitializers !=
131 FormatStyle::BCIS_BeforeComma) &&
132 (Previous.
isNot(TT_InheritanceComma) ||
133 Style.BreakInheritanceList != FormatStyle::BILS_BeforeComma));
138 if (LessTok.
isNot(tok::less))
140 return Style.Language == FormatStyle::LK_TextProto ||
141 (Style.Language == FormatStyle::LK_Proto &&
150 if (TokenText.size() < 5
151 || !TokenText.startswith(
"R\"") || !TokenText.endswith(
"\""))
157 size_t LParenPos = TokenText.substr(0, 19).find_first_of(
'(');
158 if (LParenPos == StringRef::npos)
160 StringRef Delimiter = TokenText.substr(2, LParenPos - 2);
163 size_t RParenPos = TokenText.size() - Delimiter.size() - 2;
164 if (TokenText[RParenPos] !=
')')
166 if (!TokenText.substr(RParenPos + 1).startswith(Delimiter))
175 FormatStyle::LanguageKind
Language) {
176 for (
const auto &Format : Style.RawStringFormats) {
177 if (Format.Language == Language)
178 return StringRef(Format.CanonicalDelimiter);
185 for (
const auto &RawStringFormat : CodeStyle.RawStringFormats) {
187 CodeStyle.GetLanguageStyle(RawStringFormat.Language);
188 if (!LanguageStyle) {
191 RawStringFormat.Language, &PredefinedStyle)) {
193 PredefinedStyle.Language = RawStringFormat.Language;
195 LanguageStyle = PredefinedStyle;
197 LanguageStyle->ColumnLimit = CodeStyle.ColumnLimit;
198 for (StringRef Delimiter : RawStringFormat.Delimiters) {
201 for (StringRef EnclosingFunction : RawStringFormat.EnclosingFunctions) {
217 StringRef EnclosingFunction)
const {
229 bool BinPackInconclusiveFunctions)
230 : Style(Style), Keywords(Keywords), SourceMgr(SourceMgr),
231 Whitespaces(Whitespaces), Encoding(Encoding),
232 BinPackInconclusiveFunctions(BinPackInconclusiveFunctions),
233 CommentPragmasRegex(Style.CommentPragmas), RawStringFormats(Style) {}
236 unsigned FirstStartColumn,
242 State.
Column = FirstStartColumn;
244 State.
Column = FirstIndent;
248 if (Style.IndentPPDirectives == FormatStyle::PPDIS_AfterHash &&
264 if (Style.Language == FormatStyle::LK_TextProto) {
267 State.
Stack.back().AvoidBinPacking =
true;
268 State.
Stack.back().BreakBeforeParameter =
true;
269 State.
Stack.back().AlignColons =
false;
273 moveStateToNextToken(State, DryRun,
false);
280 assert(&Previous == Current.
Previous);
305 if (Previous.
is(tok::l_brace) && State.
Stack.size() > 1 &&
306 State.
Stack[State.
Stack.size() - 2].NestedBlockInlined &&
307 State.
Stack[State.
Stack.size() - 2].HasMultipleNestedBlocks)
312 if (Current.
is(TT_FunctionDeclarationName) && State.
Column < 6) {
313 if (Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None)
319 if (!Current.
isOneOf(TT_BinaryOperator, tok::comma) &&
320 State.
Stack.back().NoLineBreakInOperand)
323 if (Previous.
is(tok::l_square) && Previous.
is(TT_ObjCMethodExpr))
326 return !State.
Stack.back().NoLineBreak;
334 if (State.
Stack.back().BreakBeforeClosingBrace &&
339 if (Style.Language == FormatStyle::LK_ObjC &&
341 Current.
startsSequence(TT_SelectorName, tok::colon, tok::caret)) {
345 (Previous.
is(TT_TemplateCloser) && Current.
is(TT_StartOfName) &&
351 (Previous.
NestingLevel == 1 || Style.BinPackParameters)) ||
352 (Style.BreakBeforeTernaryOperators && Current.
is(TT_ConditionalExpr) &&
353 Previous.
isNot(tok::question)) ||
354 (!Style.BreakBeforeTernaryOperators &&
355 Previous.
is(TT_ConditionalExpr))) &&
357 !Current.
isOneOf(tok::r_paren, tok::r_brace))
359 if (((Previous.
is(TT_DictLiteral) && Previous.
is(tok::l_brace)) ||
360 (Previous.
is(TT_ArrayInitializerLSquare) &&
363 Style.ColumnLimit > 0 &&
368 const FormatToken &BreakConstructorInitializersToken =
369 Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon
372 if (BreakConstructorInitializersToken.
is(TT_CtorInitializerColon) &&
375 State.
Stack.back().BreakBeforeParameter) &&
376 (Style.AllowShortFunctionsOnASingleLine != FormatStyle::SFS_All ||
377 Style.BreakConstructorInitializers != FormatStyle::BCIS_BeforeColon ||
378 Style.ColumnLimit != 0))
381 if (Current.
is(TT_ObjCMethodExpr) && !Previous.
is(TT_SelectorName) &&
384 if (Current.
is(TT_SelectorName) && !Previous.
is(tok::at) &&
385 State.
Stack.back().ObjCSelectorNameFound &&
386 State.
Stack.back().BreakBeforeParameter)
389 unsigned NewLineColumn = getNewLineColumn(State);
392 (State.
Column > NewLineColumn ||
397 (State.
Stack.back().CallContinuation != 0 ||
398 State.
Stack.back().BreakBeforeParameter) &&
404 !(State.
Column <= NewLineColumn &&
405 Style.Language == FormatStyle::LK_JavaScript) &&
415 if (State.
Column <= NewLineColumn)
418 if (Style.AlwaysBreakBeforeMultilineStrings &&
419 (NewLineColumn == State.
FirstIndent + Style.ContinuationIndentWidth ||
421 !Previous.
isOneOf(tok::kw_return, tok::lessless, tok::at,
423 !Previous.
isOneOf(TT_InlineASMColon, TT_ConditionalExpr) &&
424 nextIsMultilineString(State))
445 bool LHSIsBinaryExpr =
449 State.
Stack.back().BreakBeforeParameter)
452 State.
Stack.back().BreakBeforeParameter) {
457 if (Current.
is(tok::lessless) && Current.
isNot(TT_OverloadedOperator) &&
458 State.
Stack.back().BreakBeforeParameter &&
459 State.
Stack.back().FirstLessLess == 0)
467 return Style.AlwaysBreakTemplateDeclarations != FormatStyle::BTDS_No;
468 if (Previous.
is(TT_FunctionAnnotationRParen))
470 if (Previous.
is(TT_LeadingJavaAnnotation) && Current.
isNot(tok::l_paren) &&
471 Current.
isNot(TT_LeadingJavaAnnotation))
476 if (((Current.
is(TT_FunctionDeclarationName) &&
478 (!Style.isCSharp() ||
479 Style.AlwaysBreakAfterReturnType != FormatStyle::RTBS_None)) ||
480 (Current.
is(tok::kw_operator) && !Previous.
is(tok::coloncolon))) &&
481 !Previous.
is(tok::kw_template) && State.
Stack.back().BreakBeforeParameter)
488 Previous.
is(tok::l_brace) && !Current.
isOneOf(tok::r_brace, tok::comment))
491 if (Current.
is(tok::lessless) &&
492 ((Previous.
is(tok::identifier) && Previous.
TokenText ==
"endl") ||
508 unsigned ExtraSpaces) {
511 assert(!State.
Stack.empty());
514 if ((Current.
is(TT_ImplicitStringLiteral) &&
517 tok::pp_not_keyword))) {
525 unsigned StartColumn =
527 assert(EndColumn >= StartColumn);
528 State.
Column += EndColumn - StartColumn;
530 moveStateToNextToken(State, DryRun,
false);
534 unsigned Penalty = 0;
536 Penalty = addTokenOnNewLine(State, DryRun);
538 addTokenOnCurrentLine(State, DryRun, ExtraSpaces);
540 return moveStateToNextToken(State, DryRun, Newline) + Penalty;
543 void ContinuationIndenter::addTokenOnCurrentLine(
LineState &
State,
bool DryRun,
544 unsigned ExtraSpaces) {
547 if (Current.
is(tok::equal) &&
549 State.
Stack.back().VariablePos == 0) {
560 State.
Stack.back().LastSpace = State.
Stack.back().VariablePos;
566 int PPColumnCorrection = 0;
567 if (Style.IndentPPDirectives == FormatStyle::PPDIS_AfterHash &&
577 if (Style.UseTab != FormatStyle::UT_Never)
578 PPColumnCorrection = -1;
583 State.
Column + Spaces + PPColumnCorrection);
587 if (Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma &&
588 Current.
is(TT_InheritanceColon))
589 State.
Stack.back().NoLineBreak =
true;
590 if (Style.BreakInheritanceList == FormatStyle::BILS_AfterColon &&
591 Previous.
is(TT_InheritanceColon))
592 State.
Stack.back().NoLineBreak =
true;
594 if (Current.
is(TT_SelectorName) &&
595 !State.
Stack.back().ObjCSelectorNameFound) {
598 State.
Stack.back().Indent);
601 State.
Stack.back().AlignColons =
false;
605 State.
Stack.back().ColonPos = FirstColonPos;
612 (Previous.
isOneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) ||
614 Style.Cpp11BracedListStyle)) &&
615 State.
Column > getNewLineColumn(State) &&
617 tok::kw_for, tok::kw_while, tok::kw_switch)) &&
627 State.
Stack.back().NoLineBreak =
true;
628 if (Previous.
is(TT_TemplateString) && Previous.
opensScope())
629 State.
Stack.back().NoLineBreak =
true;
636 State.
Stack.back().NoLineBreak =
true;
638 State.
Column > getNewLineColumn(State))
639 State.
Stack.back().ContainsUnwrappedBuilder =
true;
641 if (Current.
is(TT_LambdaArrow) && Style.Language == FormatStyle::LK_Java)
642 State.
Stack.back().NoLineBreak =
true;
652 State.
Stack.back().NoLineBreak =
true;
659 if (!Current.
is(tok::comment) && P &&
660 (P->
isOneOf(TT_BinaryOperator, tok::comma) ||
661 (P->
is(TT_ConditionalExpr) && P->
is(tok::colon))) &&
662 !P->
isOneOf(TT_OverloadedOperator, TT_CtorInitializerComma) &&
666 bool BreakBeforeOperator =
668 (P->
is(TT_BinaryOperator) &&
669 Style.BreakBeforeBinaryOperators != FormatStyle::BOS_None) ||
670 (P->
is(TT_ConditionalExpr) && Style.BreakBeforeTernaryOperators);
674 bool HasTwoOperands =
676 if ((!BreakBeforeOperator && !(HasTwoOperands && Style.
AlignOperands)) ||
677 (!State.
Stack.back().LastOperatorWrapped && BreakBeforeOperator))
678 State.
Stack.back().NoLineBreakInOperand =
true;
682 if (Current.
isNot(tok::comment) && Previous.
is(tok::l_paren) &&
688 State.
Stack.back().NestedBlockIndent = State.
Column;
689 }
else if (!Current.
isOneOf(tok::comment, tok::caret) &&
690 ((Previous.
is(tok::comma) &&
691 !Previous.
is(TT_OverloadedOperator)) ||
692 (Previous.
is(tok::colon) && Previous.
is(TT_ObjCMethodExpr)))) {
694 }
else if (Previous.
is(TT_CtorInitializerColon) &&
695 Style.BreakConstructorInitializers ==
696 FormatStyle::BCIS_AfterColon) {
699 }
else if ((Previous.
isOneOf(TT_BinaryOperator, TT_ConditionalExpr,
700 TT_CtorInitializerColon)) &&
708 if (Style.BreakBeforeBinaryOperators == FormatStyle::BOS_None)
710 }
else if (Previous.
is(TT_InheritanceColon)) {
719 bool HasTrailingCall =
false;
724 if (HasTrailingCall && State.
Stack.size() > 1 &&
725 State.
Stack[State.
Stack.size() - 2].CallContinuation == 0)
730 unsigned ContinuationIndenter::addTokenOnNewLine(
LineState &State,
737 unsigned Penalty = 0;
742 NextNonComment = &Current;
745 if (!State.
Stack.back().ContainsLineBreak)
747 State.
Stack.back().ContainsLineBreak =
true;
754 if (NextNonComment->
is(tok::lessless) &&
755 State.
Stack.back().FirstLessLess == 0 &&
756 (State.
Column <= Style.ColumnLimit / 3 ||
757 State.
Stack.back().BreakBeforeParameter))
758 Penalty += Style.PenaltyBreakFirstLessLess;
760 State.
Column = getNewLineColumn(State);
772 if (!Current.
is(TT_LambdaArrow) &&
773 (Style.Language != FormatStyle::LK_JavaScript ||
775 !PreviousNonComment->
is(tok::equal) ||
777 State.
Stack.back().NestedBlockIndent = State.
Column;
780 if (State.
Stack.back().CallContinuation == 0)
781 State.
Stack.back().CallContinuation = State.
Column;
782 }
else if (NextNonComment->
is(TT_SelectorName)) {
783 if (!State.
Stack.back().ObjCSelectorNameFound) {
785 State.
Stack.back().AlignColons =
false;
787 State.
Stack.back().ColonPos =
791 : State.
Stack.back().Indent) +
795 }
else if (State.
Stack.back().AlignColons &&
799 }
else if (PreviousNonComment && PreviousNonComment->
is(tok::colon) &&
800 PreviousNonComment->
isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) {
810 if (State.
Stack.size() > 1)
811 State.
Stack[State.
Stack.size() - 2].LastSpace =
813 Style.ContinuationIndentWidth;
816 if ((PreviousNonComment &&
817 PreviousNonComment->
isOneOf(tok::comma, tok::semi) &&
818 !State.
Stack.back().AvoidBinPacking) ||
819 Previous.
is(TT_BinaryOperator))
820 State.
Stack.back().BreakBeforeParameter =
false;
821 if (PreviousNonComment &&
822 PreviousNonComment->
isOneOf(TT_TemplateCloser, TT_JavaAnnotation) &&
824 State.
Stack.back().BreakBeforeParameter =
false;
825 if (NextNonComment->
is(tok::question) ||
826 (PreviousNonComment && PreviousNonComment->
is(tok::question)))
827 State.
Stack.back().BreakBeforeParameter =
true;
829 State.
Stack.back().BreakBeforeParameter =
false;
832 unsigned MaxEmptyLinesToKeep = Style.MaxEmptyLinesToKeep + 1;
840 MaxEmptyLinesToKeep = 1;
844 bool ContinuePPDirective =
847 ContinuePPDirective);
852 if (Current.
is(tok::lessless))
856 State.
Stack.back().LastSpace += 3;
863 bool NestedBlockSpecialCase =
864 !Style.isCpp() && Current.
is(tok::r_brace) && State.
Stack.size() > 1 &&
865 State.
Stack[State.
Stack.size() - 2].NestedBlockInlined;
866 if (!NestedBlockSpecialCase)
867 for (
unsigned i = 0, e = State.
Stack.size() - 1; i != e; ++i)
868 State.
Stack[i].BreakBeforeParameter =
true;
870 if (PreviousNonComment &&
871 !PreviousNonComment->
isOneOf(tok::comma, tok::colon, tok::semi) &&
872 (PreviousNonComment->
isNot(TT_TemplateCloser) ||
875 TT_BinaryOperator, TT_FunctionAnnotationRParen, TT_JavaAnnotation,
876 TT_LeadingJavaAnnotation) &&
878 State.
Stack.back().BreakBeforeParameter =
true;
882 if (PreviousNonComment &&
883 (PreviousNonComment->
isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
885 State.
Stack.back().BreakBeforeClosingBrace =
true;
887 if (State.
Stack.back().AvoidBinPacking) {
892 bool PreviousIsBreakingCtorInitializerColon =
893 Previous.
is(TT_CtorInitializerColon) &&
894 Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon;
895 if (!(Previous.
isOneOf(tok::l_paren, tok::l_brace, TT_BinaryOperator) ||
896 PreviousIsBreakingCtorInitializerColon) ||
897 (!Style.AllowAllParametersOfDeclarationOnNextLine &&
901 (!Style.AllowAllConstructorInitializersOnNextLine &&
902 PreviousIsBreakingCtorInitializerColon) ||
903 Previous.
is(TT_DictLiteral))
904 State.
Stack.back().BreakBeforeParameter =
true;
909 if (PreviousIsBreakingCtorInitializerColon &&
910 Style.AllowAllConstructorInitializersOnNextLine)
911 State.
Stack.back().BreakBeforeParameter =
false;
917 unsigned ContinuationIndenter::getNewLineColumn(
const LineState &State) {
923 unsigned ContinuationIndent =
925 Style.ContinuationIndentWidth;
929 NextNonComment = &Current;
932 if (Style.Language == FormatStyle::LK_Java &&
935 State.
Stack.back().Indent + Style.ContinuationIndentWidth);
937 if (Style.BreakBeforeBraces == FormatStyle::BS_Whitesmiths &&
944 : State.
Stack.back().Indent;
945 if ((Current.
isOneOf(tok::r_brace, tok::r_square) ||
946 (Current.
is(tok::greater) &&
947 (Style.Language == FormatStyle::LK_Proto ||
948 Style.Language == FormatStyle::LK_TextProto))) &&
949 State.
Stack.size() > 1) {
951 return State.
Stack[State.
Stack.size() - 2].NestedBlockIndent;
954 return State.
Stack[State.
Stack.size() - 2].LastSpace;
972 if (Current.
is(tok::r_paren) && State.
Stack.size() > 1 &&
974 Current.
Next->
isOneOf(tok::semi, tok::kw_const, tok::l_brace)))
975 return State.
Stack[State.
Stack.size() - 2].LastSpace;
976 if (NextNonComment->
is(TT_TemplateString) && NextNonComment->
closesScope())
977 return State.
Stack[State.
Stack.size() - 2].LastSpace;
978 if (Current.
is(tok::identifier) && Current.
Next &&
979 (Current.
Next->
is(TT_DictLiteral) ||
980 ((Style.Language == FormatStyle::LK_Proto ||
981 Style.Language == FormatStyle::LK_TextProto) &&
983 return State.
Stack.back().Indent;
984 if (NextNonComment->
is(TT_ObjCStringLiteral) &&
989 if (NextNonComment->
is(tok::lessless) &&
990 State.
Stack.back().FirstLessLess != 0)
991 return State.
Stack.back().FirstLessLess;
993 if (State.
Stack.back().CallContinuation == 0)
994 return ContinuationIndent;
995 return State.
Stack.back().CallContinuation;
997 if (State.
Stack.back().QuestionColumn != 0 &&
998 ((NextNonComment->
is(tok::colon) &&
999 NextNonComment->
is(TT_ConditionalExpr)) ||
1000 Previous.
is(TT_ConditionalExpr)))
1001 return State.
Stack.back().QuestionColumn;
1002 if (Previous.
is(tok::comma) && State.
Stack.back().VariablePos != 0)
1003 return State.
Stack.back().VariablePos;
1004 if ((PreviousNonComment &&
1005 (PreviousNonComment->ClosesTemplateDeclaration ||
1006 PreviousNonComment->isOneOf(
1007 TT_AttributeParen, TT_AttributeSquare, TT_FunctionAnnotationRParen,
1008 TT_JavaAnnotation, TT_LeadingJavaAnnotation))) ||
1009 (!Style.IndentWrappedFunctionNames &&
1010 NextNonComment->
isOneOf(tok::kw_operator, TT_FunctionDeclarationName)))
1012 if (NextNonComment->
is(TT_SelectorName)) {
1013 if (!State.
Stack.back().ObjCSelectorNameFound) {
1014 unsigned MinIndent = State.
Stack.back().Indent;
1017 State.
FirstIndent + Style.ContinuationIndentWidth);
1032 if (!State.
Stack.back().AlignColons)
1033 return State.
Stack.back().Indent;
1036 return State.
Stack.back().Indent;
1038 if (NextNonComment->
is(tok::colon) && NextNonComment->
is(TT_ObjCMethodExpr))
1039 return State.
Stack.back().ColonPos;
1040 if (NextNonComment->
is(TT_ArraySubscriptLSquare)) {
1041 if (State.
Stack.back().StartOfArraySubscripts != 0)
1042 return State.
Stack.back().StartOfArraySubscripts;
1043 return ContinuationIndent;
1048 if (NextNonComment->
is(tok::identifier) && NextNonComment->
FakeRParens == 0 &&
1049 NextNonComment->
Next && NextNonComment->
Next->
is(TT_ObjCMethodExpr))
1050 return State.
Stack.back().Indent;
1052 if (NextNonComment->
isOneOf(TT_StartOfName, TT_PointerOrReference) ||
1053 Previous.
isOneOf(tok::coloncolon, tok::equal, TT_JsTypeColon))
1054 return ContinuationIndent;
1055 if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
1056 PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral))
1057 return ContinuationIndent;
1058 if (NextNonComment->
is(TT_CtorInitializerComma))
1059 return State.
Stack.back().Indent;
1060 if (PreviousNonComment && PreviousNonComment->is(TT_CtorInitializerColon) &&
1061 Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon)
1062 return State.
Stack.back().Indent;
1063 if (PreviousNonComment && PreviousNonComment->is(TT_InheritanceColon) &&
1064 Style.BreakInheritanceList == FormatStyle::BILS_AfterColon)
1065 return State.
Stack.back().Indent;
1066 if (NextNonComment->
isOneOf(TT_CtorInitializerColon, TT_InheritanceColon,
1067 TT_InheritanceComma))
1068 return State.
FirstIndent + Style.ConstructorInitializerIndentWidth;
1070 !Current.
isOneOf(tok::colon, tok::comment))
1071 return ContinuationIndent;
1072 if (Current.
is(TT_ProtoExtensionLSquare))
1073 return State.
Stack.back().Indent;
1074 if (State.
Stack.back().Indent == State.
FirstIndent && PreviousNonComment &&
1075 !PreviousNonComment->isOneOf(tok::r_brace, TT_CtorInitializerComma))
1078 return State.
Stack.back().Indent + Style.ContinuationIndentWidth;
1079 return State.
Stack.back().Indent;
1082 unsigned ContinuationIndenter::moveStateToNextToken(
LineState &State,
1083 bool DryRun,
bool Newline) {
1084 assert(State.
Stack.size());
1087 if (Current.isOneOf(tok::comma, TT_BinaryOperator))
1088 State.
Stack.back().NoLineBreakInOperand =
false;
1089 if (Current.is(TT_InheritanceColon))
1090 State.
Stack.back().AvoidBinPacking =
true;
1091 if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) {
1092 if (State.
Stack.back().FirstLessLess == 0)
1095 State.
Stack.back().LastOperatorWrapped = Newline;
1097 if (Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless))
1098 State.
Stack.back().LastOperatorWrapped = Newline;
1099 if (Current.is(TT_ConditionalExpr) && Current.Previous &&
1100 !Current.Previous->is(TT_ConditionalExpr))
1101 State.
Stack.back().LastOperatorWrapped = Newline;
1102 if (Current.is(TT_ArraySubscriptLSquare) &&
1103 State.
Stack.back().StartOfArraySubscripts == 0)
1104 State.
Stack.back().StartOfArraySubscripts = State.
Column;
1105 if (Style.BreakBeforeTernaryOperators && Current.is(tok::question))
1107 if (!Style.BreakBeforeTernaryOperators && Current.isNot(tok::colon)) {
1111 if (Previous && Previous->
is(tok::question))
1114 if (!Current.opensScope() && !Current.closesScope() &&
1115 !Current.is(TT_PointerOrReference))
1118 if (Current.isMemberAccess())
1119 State.
Stack.back().StartOfFunctionCall =
1120 !Current.NextOperator ? 0 : State.
Column;
1121 if (Current.is(TT_SelectorName))
1122 State.
Stack.back().ObjCSelectorNameFound =
true;
1123 if (Current.is(TT_CtorInitializerColon) &&
1124 Style.BreakConstructorInitializers != FormatStyle::BCIS_AfterColon) {
1130 State.
Stack.back().Indent =
1132 (Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma
1135 State.
Stack.back().NestedBlockIndent = State.
Stack.back().Indent;
1136 if (Style.ConstructorInitializerAllOnOneLineOrOnePerLine) {
1137 State.
Stack.back().AvoidBinPacking =
true;
1138 State.
Stack.back().BreakBeforeParameter =
1139 !Style.AllowAllConstructorInitializersOnNextLine;
1141 State.
Stack.back().BreakBeforeParameter =
false;
1144 if (Current.is(TT_CtorInitializerColon) &&
1145 Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon) {
1146 State.
Stack.back().Indent =
1147 State.
FirstIndent + Style.ConstructorInitializerIndentWidth;
1148 State.
Stack.back().NestedBlockIndent = State.
Stack.back().Indent;
1149 if (Style.ConstructorInitializerAllOnOneLineOrOnePerLine)
1150 State.
Stack.back().AvoidBinPacking =
true;
1152 if (Current.is(TT_InheritanceColon))
1153 State.
Stack.back().Indent =
1154 State.
FirstIndent + Style.ConstructorInitializerIndentWidth;
1155 if (Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline)
1156 State.
Stack.back().NestedBlockIndent =
1157 State.
Column + Current.ColumnWidth + 1;
1158 if (Current.isOneOf(TT_LambdaLSquare, TT_LambdaArrow))
1170 if (Current.isNot(tok::comment) && Previous &&
1171 Previous->
isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&
1172 !Previous->
is(TT_DictLiteral) && State.
Stack.size() > 1 &&
1173 !State.
Stack.back().HasMultipleNestedBlocks) {
1174 if (State.
Stack[State.
Stack.size() - 2].NestedBlockInlined && Newline)
1175 for (
unsigned i = 0, e = State.
Stack.size() - 1; i != e; ++i)
1176 State.
Stack[i].NoLineBreak =
true;
1177 State.
Stack[State.
Stack.size() - 2].NestedBlockInlined =
false;
1180 (Previous->
isOneOf(tok::l_paren, tok::comma, tok::colon) ||
1181 Previous->
isOneOf(TT_BinaryOperator, TT_ConditionalExpr)) &&
1182 !Previous->
isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)) {
1183 State.
Stack.back().NestedBlockInlined =
1188 moveStatePastFakeLParens(State, Newline);
1189 moveStatePastScopeCloser(State);
1190 bool AllowBreak = !State.
Stack.back().NoLineBreak &&
1191 !State.
Stack.back().NoLineBreakInOperand;
1192 moveStatePastScopeOpener(State, Newline);
1193 moveStatePastFakeRParens(State);
1201 else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) &&
1202 !Current.isStringLiteral())
1205 State.
Column += Current.ColumnWidth;
1209 handleEndOfLine(Current, State, DryRun, AllowBreak, Newline);
1212 Current.Role->formatFromToken(State,
this, DryRun);
1218 if (Previous && Previous->
Role)
1219 Penalty += Previous->
Role->formatAfterToken(State,
this, DryRun);
1224 void ContinuationIndenter::moveStatePastFakeLParens(
LineState &State,
1232 bool SkipFirstExtraIndent =
1234 Previous->
isOneOf(tok::semi, tok::kw_return) ||
1237 Previous->
is(TT_ObjCMethodExpr)));
1243 NewParenState.
Tok =
nullptr;
1258 (!Previous || Previous->
isNot(tok::kw_return) ||
1259 (Style.Language != FormatStyle::LK_Java && *I > 0)) &&
1264 State.
Stack.back().LastSpace);
1285 NewParenState.
Indent += Style.ContinuationIndentWidth;
1288 State.
Stack.push_back(NewParenState);
1289 SkipFirstExtraIndent =
false;
1293 void ContinuationIndenter::moveStatePastFakeRParens(
LineState &State) {
1295 unsigned VariablePos = State.
Stack.back().VariablePos;
1296 if (State.
Stack.size() == 1) {
1300 State.
Stack.pop_back();
1301 State.
Stack.back().VariablePos = VariablePos;
1305 void ContinuationIndenter::moveStatePastScopeOpener(
LineState &State,
1312 moveStateToNewBlock(State);
1317 unsigned LastSpace = State.
Stack.back().LastSpace;
1318 bool AvoidBinPacking;
1319 bool BreakBeforeParameter =
false;
1320 unsigned NestedBlockIndent =
std::max(State.
Stack.back().StartOfFunctionCall,
1321 State.
Stack.back().NestedBlockIndent);
1322 if (Current.
isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
1325 NewIndent = Style.IndentWidth +
1328 NewIndent = State.
Stack.back().LastSpace + Style.ContinuationIndentWidth;
1334 AvoidBinPacking = EndsInComma || Current.
is(TT_DictLiteral) ||
1335 Style.Language == FormatStyle::LK_Proto ||
1336 Style.Language == FormatStyle::LK_TextProto ||
1337 !Style.BinPackArguments ||
1339 NextNoComment->
isOneOf(TT_DesignatedInitializerPeriod,
1340 TT_DesignatedInitializerLSquare));
1341 BreakBeforeParameter = EndsInComma;
1343 NestedBlockIndent =
std::max(NestedBlockIndent, State.
Column + 1);
1345 NewIndent = Style.ContinuationIndentWidth +
1347 State.
Stack.back().StartOfFunctionCall);
1365 bool ObjCBinPackProtocolList =
1366 (Style.ObjCBinPackProtocolList == FormatStyle::BPS_Auto &&
1367 Style.BinPackParameters) ||
1368 Style.ObjCBinPackProtocolList == FormatStyle::BPS_Always;
1370 bool BinPackDeclaration =
1375 (Style.Language == FormatStyle::LK_JavaScript && EndsInComma) ||
1378 (Style.ExperimentalAutoDetectBinPacking &&
1380 (!BinPackInconclusiveFunctions &&
1384 if (Style.ColumnLimit) {
1389 BreakBeforeParameter =
true;
1397 BreakBeforeParameter =
true;
1404 if (Style.Language == FormatStyle::LK_JavaScript && EndsInComma)
1405 BreakBeforeParameter =
true;
1412 !Current.
isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) &&
1413 (State.
Stack.back().NoLineBreak ||
1414 State.
Stack.back().NoLineBreakInOperand ||
1415 (Current.
is(TT_TemplateOpener) &&
1416 State.
Stack.back().ContainsUnwrappedBuilder));
1417 State.
Stack.push_back(
1418 ParenState(&Current, NewIndent, LastSpace, AvoidBinPacking, NoLineBreak));
1419 State.
Stack.back().NestedBlockIndent = NestedBlockIndent;
1420 State.
Stack.back().BreakBeforeParameter = BreakBeforeParameter;
1422 State.
Stack.back().IsInsideObjCArrayLiteral =
1423 Current.
is(TT_ArrayInitializerLSquare) && Current.
Previous &&
1427 void ContinuationIndenter::moveStatePastScopeCloser(
LineState &State) {
1434 if (State.
Stack.size() > 1 &&
1435 (Current.
isOneOf(tok::r_paren, tok::r_square, TT_TemplateString) ||
1438 (Current.
is(tok::greater) && Current.
is(TT_DictLiteral))))
1439 State.
Stack.pop_back();
1454 if (CurrentScopeOpener.
is(TT_ObjCMethodExpr) &&
1456 int NecessarySpaceInLine =
1461 State.
Stack.back().BreakBeforeParameter =
false;
1465 if (Current.
is(tok::r_square)) {
1468 if (NextNonComment && NextNonComment->
isNot(tok::l_square))
1469 State.
Stack.back().StartOfArraySubscripts = 0;
1473 void ContinuationIndenter::moveStateToNewBlock(
LineState &State) {
1474 unsigned NestedBlockIndent = State.
Stack.back().NestedBlockIndent;
1476 unsigned NewIndent =
1477 NestedBlockIndent + (State.
NextToken->
is(TT_ObjCBlockLBrace)
1478 ? Style.ObjCBlockIndentWidth
1479 : Style.IndentWidth);
1481 State.
Stack.back().LastSpace,
1484 State.
Stack.back().NestedBlockIndent = NestedBlockIndent;
1485 State.
Stack.back().BreakBeforeParameter =
true;
1491 size_t LastNewlinePos = Text.find_last_of(
"\n");
1492 if (LastNewlinePos == StringRef::npos) {
1493 return StartColumn +
1497 0, TabWidth, Encoding);
1501 unsigned ContinuationIndenter::reformatRawStringLiteral(
1503 const FormatStyle &RawStringStyle,
bool DryRun,
bool Newline) {
1506 StringRef NewDelimiter =
1508 if (NewDelimiter.empty() || OldDelimiter.empty())
1509 NewDelimiter = OldDelimiter;
1512 unsigned OldPrefixSize = 3 + OldDelimiter.size();
1513 unsigned OldSuffixSize = 2 + OldDelimiter.size();
1516 std::string RawText =
1517 Current.
TokenText.substr(OldPrefixSize).drop_back(OldSuffixSize);
1518 if (NewDelimiter != OldDelimiter) {
1521 std::string CanonicalDelimiterSuffix = (
")" + NewDelimiter +
"\"").str();
1522 if (StringRef(RawText).contains(CanonicalDelimiterSuffix))
1523 NewDelimiter = OldDelimiter;
1526 unsigned NewPrefixSize = 3 + NewDelimiter.size();
1527 unsigned NewSuffixSize = 2 + NewDelimiter.size();
1530 unsigned FirstStartColumn = StartColumn + NewPrefixSize;
1541 bool ContentStartsOnNewline = Current.
TokenText[OldPrefixSize] ==
'\n';
1563 unsigned CurrentIndent =
1564 (!Newline && Current.
Next && Current.
Next->
is(tok::r_paren))
1565 ? State.
Stack.back().NestedBlockIndent
1566 : State.
Stack.back().Indent;
1567 unsigned NextStartColumn = ContentStartsOnNewline
1568 ? CurrentIndent + Style.IndentWidth
1579 unsigned LastStartColumn =
1580 Current.
NewlinesBefore ? FirstStartColumn - NewPrefixSize : CurrentIndent;
1584 FirstStartColumn, NextStartColumn, LastStartColumn,
"<stdin>",
1590 return addMultilineToken(Current, State);
1593 if (NewDelimiter != OldDelimiter) {
1599 SourceMgr, PrefixDelimiterStart, OldDelimiter.size(), NewDelimiter));
1602 <<
"Failed to update the prefix delimiter of a raw string: " 1609 1 - OldDelimiter.size());
1611 SourceMgr, SuffixDelimiterStart, OldDelimiter.size(), NewDelimiter));
1614 <<
"Failed to update the suffix delimiter of a raw string: " 1625 llvm::errs() <<
"Failed to reformat raw string: " 1631 *NewCode, FirstStartColumn, Style.TabWidth, Encoding);
1632 State.
Column = RawLastLineEndColumn + NewSuffixSize;
1636 unsigned PrefixExcessCharacters =
1637 StartColumn + NewPrefixSize > Style.ColumnLimit
1638 ? StartColumn + NewPrefixSize - Style.ColumnLimit
1641 ContentStartsOnNewline || (NewCode->find(
'\n') != std::string::npos);
1644 for (
unsigned i = 0, e = State.
Stack.size(); i != e; ++i)
1645 State.
Stack[i].BreakBeforeParameter =
true;
1647 return Fixes.second + PrefixExcessCharacters * Style.PenaltyExcessCharacter;
1650 unsigned ContinuationIndenter::addMultilineToken(
const FormatToken &Current,
1653 for (
unsigned i = 0, e = State.
Stack.size(); i != e; ++i)
1654 State.
Stack[i].BreakBeforeParameter =
true;
1656 unsigned ColumnsUsed = State.
Column;
1662 return Style.PenaltyExcessCharacter * (ColumnsUsed -
getColumnLimit(State));
1666 unsigned ContinuationIndenter::handleEndOfLine(
const FormatToken &Current,
1668 bool AllowBreak,
bool Newline) {
1669 unsigned Penalty = 0;
1672 auto RawStringStyle = getRawStringStyle(Current, State);
1673 if (RawStringStyle && !Current.
Finalized) {
1674 Penalty = reformatRawStringLiteral(Current, State, *RawStringStyle, DryRun,
1679 Penalty = addMultilineToken(Current, State);
1686 bool Strict =
false;
1689 bool Exceeded =
false;
1690 std::tie(Penalty, Exceeded) = breakProtrudingToken(
1691 Current, State, AllowBreak,
true, Strict);
1696 unsigned StrictPenalty =
1697 breakProtrudingToken(Current, StrictState, AllowBreak,
1700 Strict = StrictPenalty <= Penalty;
1702 Penalty = StrictPenalty;
1703 State = StrictState;
1709 breakProtrudingToken(Current, OriginalState, AllowBreak,
false,
1715 Penalty += Style.PenaltyExcessCharacter * ExcessCharacters;
1725 if (!
Tok || !
Tok->
is(tok::l_paren))
1730 if (
Tok->
is(TT_TemplateCloser)) {
1735 if (!
Tok || !
Tok->
is(tok::identifier))
1741 ContinuationIndenter::getRawStringStyle(
const FormatToken &Current,
1749 if (!RawStringStyle && Delimiter->empty())
1752 if (!RawStringStyle)
1755 return RawStringStyle;
1758 std::unique_ptr<BreakableToken>
1759 ContinuationIndenter::createBreakableToken(
const FormatToken &Current,
1766 if (Style.Language == FormatStyle::LK_Java ||
1767 Style.Language == FormatStyle::LK_JavaScript || Style.isCSharp() ||
1768 !Style.BreakStringLiterals || !AllowBreak)
1784 if (State.
Stack.back().IsInsideObjCArrayLiteral) {
1795 if ((Text.endswith(Postfix =
"\"") &&
1796 (Text.startswith(Prefix =
"@\"") || Text.startswith(Prefix =
"\"") ||
1797 Text.startswith(Prefix =
"u\"") || Text.startswith(Prefix =
"U\"") ||
1798 Text.startswith(Prefix =
"u8\"") ||
1799 Text.startswith(Prefix =
"L\""))) ||
1800 (Text.startswith(Prefix =
"_T(\"") && Text.endswith(Postfix =
"\")"))) {
1808 return std::make_unique<BreakableStringLiteral>(
1809 Current, StartColumn, Prefix, Postfix, UnbreakableTailLength,
1812 }
else if (Current.
is(TT_BlockComment)) {
1813 if (!Style.ReflowComments ||
1820 return std::make_unique<BreakableBlockComment>(
1823 }
else if (Current.
is(TT_LineComment) &&
1826 if (!Style.ReflowComments ||
1827 CommentPragmasRegex.match(Current.
TokenText.substr(2)) ||
1830 return std::make_unique<BreakableLineCommentSection>(
1832 false, Encoding, Style);
1837 std::pair<unsigned, bool>
1838 ContinuationIndenter::breakProtrudingToken(
const FormatToken &Current,
1840 bool DryRun,
bool Strict) {
1841 std::unique_ptr<const BreakableToken>
Token =
1842 createBreakableToken(Current, State, AllowBreak);
1845 assert(Token->getLineCount() > 0);
1847 if (Current.
is(TT_LineComment)) {
1849 ColumnLimit = Style.ColumnLimit;
1857 ? Style.PenaltyBreakString
1858 : Style.PenaltyBreakComment;
1861 bool Exceeded =
false;
1863 bool BreakInserted = Token->introducesBreakBeforeToken();
1866 bool NewBreakBefore =
false;
1870 bool Reflow =
false;
1873 unsigned TailOffset = 0;
1875 unsigned ContentStartColumn =
1876 Token->getContentStartColumn(0,
false);
1878 unsigned RemainingTokenColumns =
1879 Token->getRemainingLength(0, TailOffset, ContentStartColumn);
1882 Token->adaptStartOfLine(0, Whitespaces);
1884 unsigned ContentIndent = 0;
1885 unsigned Penalty = 0;
1886 LLVM_DEBUG(llvm::dbgs() <<
"Breaking protruding token at column " 1887 << StartColumn <<
".\n");
1888 for (
unsigned LineIndex = 0, EndIndex = Token->getLineCount();
1889 LineIndex != EndIndex; ++LineIndex) {
1890 LLVM_DEBUG(llvm::dbgs()
1891 <<
" Line: " << LineIndex <<
" (Reflow: " << Reflow <<
")\n");
1892 NewBreakBefore =
false;
1896 bool TryReflow = Reflow;
1898 while (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
1899 LLVM_DEBUG(llvm::dbgs() <<
" Over limit, need: " 1900 << (ContentStartColumn + RemainingTokenColumns)
1901 <<
", space: " << ColumnLimit
1902 <<
", reflown prefix: " << ContentStartColumn
1903 <<
", offset in line: " << TailOffset <<
"\n");
1908 BreakableToken::Split
Split =
1909 Token->getSplit(LineIndex, TailOffset, ColumnLimit,
1910 ContentStartColumn, CommentPragmasRegex);
1911 if (Split.first == StringRef::npos) {
1914 if (LineIndex < EndIndex - 1)
1917 Penalty += Style.PenaltyExcessCharacter *
1918 (ContentStartColumn + RemainingTokenColumns - ColumnLimit);
1919 LLVM_DEBUG(llvm::dbgs() <<
" No break opportunity.\n");
1922 assert(Split.first != 0);
1924 if (Token->supportsReflow()) {
1944 unsigned ToSplitColumns = Token->getRangeLength(
1945 LineIndex, TailOffset, Split.first, ContentStartColumn);
1946 LLVM_DEBUG(llvm::dbgs() <<
" ToSplit: " << ToSplitColumns <<
"\n");
1948 BreakableToken::Split NextSplit = Token->getSplit(
1949 LineIndex, TailOffset + Split.first + Split.second, ColumnLimit,
1950 ContentStartColumn + ToSplitColumns + 1, CommentPragmasRegex);
1953 unsigned ToNextSplitColumns = 0;
1954 if (NextSplit.first == StringRef::npos) {
1955 ToNextSplitColumns = Token->getRemainingLength(LineIndex, TailOffset,
1956 ContentStartColumn);
1958 ToNextSplitColumns = Token->getRangeLength(
1959 LineIndex, TailOffset,
1960 Split.first + Split.second + NextSplit.first, ContentStartColumn);
1964 ToNextSplitColumns =
1965 Token->getLengthAfterCompression(ToNextSplitColumns, Split);
1966 LLVM_DEBUG(llvm::dbgs()
1967 <<
" ContentStartColumn: " << ContentStartColumn <<
"\n");
1968 LLVM_DEBUG(llvm::dbgs()
1969 <<
" ToNextSplit: " << ToNextSplitColumns <<
"\n");
1972 bool ContinueOnLine =
1973 ContentStartColumn + ToNextSplitColumns <= ColumnLimit;
1974 unsigned ExcessCharactersPenalty = 0;
1975 if (!ContinueOnLine && !Strict) {
1978 ExcessCharactersPenalty =
1979 (ContentStartColumn + ToNextSplitColumns - ColumnLimit) *
1980 Style.PenaltyExcessCharacter;
1981 LLVM_DEBUG(llvm::dbgs()
1982 <<
" Penalty excess: " << ExcessCharactersPenalty
1983 <<
"\n break : " << NewBreakPenalty <<
"\n");
1984 if (ExcessCharactersPenalty < NewBreakPenalty) {
1986 ContinueOnLine =
true;
1989 if (ContinueOnLine) {
1990 LLVM_DEBUG(llvm::dbgs() <<
" Continuing on line...\n");
1995 Token->compressWhitespace(LineIndex, TailOffset, Split,
1998 ContentStartColumn += ToSplitColumns + 1;
1999 Penalty += ExcessCharactersPenalty;
2000 TailOffset += Split.first + Split.second;
2001 RemainingTokenColumns = Token->getRemainingLength(
2002 LineIndex, TailOffset, ContentStartColumn);
2006 LLVM_DEBUG(llvm::dbgs() <<
" Breaking...\n");
2011 ContentIndent = Token->getContentIndent(LineIndex);
2012 LLVM_DEBUG(llvm::dbgs()
2013 <<
" ContentIndent: " << ContentIndent <<
"\n");
2014 ContentStartColumn = ContentIndent + Token->getContentStartColumn(
2017 unsigned NewRemainingTokenColumns = Token->getRemainingLength(
2018 LineIndex, TailOffset + Split.first + Split.second,
2019 ContentStartColumn);
2020 if (NewRemainingTokenColumns == 0) {
2023 ContentStartColumn =
2024 Token->getContentStartColumn(LineIndex,
true);
2025 NewRemainingTokenColumns = Token->getRemainingLength(
2026 LineIndex, TailOffset + Split.first + Split.second,
2027 ContentStartColumn);
2033 if (NewRemainingTokenColumns == RemainingTokenColumns) {
2037 assert(NewRemainingTokenColumns < RemainingTokenColumns);
2039 LLVM_DEBUG(llvm::dbgs() <<
" Breaking at: " << TailOffset + Split.first
2040 <<
", " << Split.second <<
"\n");
2042 Token->insertBreak(LineIndex, TailOffset, Split, ContentIndent,
2045 Penalty += NewBreakPenalty;
2046 TailOffset += Split.first + Split.second;
2047 RemainingTokenColumns = NewRemainingTokenColumns;
2048 BreakInserted =
true;
2049 NewBreakBefore =
true;
2053 if (LineIndex + 1 != EndIndex) {
2054 unsigned NextLineIndex = LineIndex + 1;
2073 ContentStartColumn += RemainingTokenColumns + 1;
2077 BreakableToken::Split SplitBeforeNext =
2078 Token->getReflowSplit(NextLineIndex, CommentPragmasRegex);
2079 LLVM_DEBUG(llvm::dbgs()
2080 <<
" Size of reflown text: " << ContentStartColumn
2081 <<
"\n Potential reflow split: ");
2082 if (SplitBeforeNext.first != StringRef::npos) {
2083 LLVM_DEBUG(llvm::dbgs() << SplitBeforeNext.first <<
", " 2084 << SplitBeforeNext.second <<
"\n");
2085 TailOffset = SplitBeforeNext.first + SplitBeforeNext.second;
2088 RemainingTokenColumns = Token->getRemainingLength(
2089 NextLineIndex, TailOffset, ContentStartColumn);
2091 if (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
2092 LLVM_DEBUG(llvm::dbgs()
2093 <<
" Over limit after reflow, need: " 2094 << (ContentStartColumn + RemainingTokenColumns)
2095 <<
", space: " << ColumnLimit
2096 <<
", reflown prefix: " << ContentStartColumn
2097 <<
", offset in line: " << TailOffset <<
"\n");
2102 BreakableToken::Split
Split =
2103 Token->getSplit(NextLineIndex, TailOffset, ColumnLimit,
2104 ContentStartColumn, CommentPragmasRegex);
2105 if (Split.first == StringRef::npos) {
2106 LLVM_DEBUG(llvm::dbgs() <<
" Did not find later break\n");
2112 unsigned ToSplitColumns = Token->getRangeLength(
2113 NextLineIndex, TailOffset, Split.first, ContentStartColumn);
2114 if (ContentStartColumn + ToSplitColumns > ColumnLimit) {
2115 LLVM_DEBUG(llvm::dbgs() <<
" Next split protrudes, need: " 2116 << (ContentStartColumn + ToSplitColumns)
2117 <<
", space: " << ColumnLimit);
2118 unsigned ExcessCharactersPenalty =
2119 (ContentStartColumn + ToSplitColumns - ColumnLimit) *
2120 Style.PenaltyExcessCharacter;
2121 if (NewBreakPenalty < ExcessCharactersPenalty) {
2128 LLVM_DEBUG(llvm::dbgs() <<
"not found.\n");
2136 ContentStartColumn =
2137 Token->getContentStartColumn(NextLineIndex,
false);
2138 RemainingTokenColumns = Token->getRemainingLength(
2139 NextLineIndex, TailOffset, ContentStartColumn);
2142 Token->adaptStartOfLine(NextLineIndex, Whitespaces);
2157 if (NewBreakBefore) {
2158 assert(Penalty >= NewBreakPenalty);
2159 Penalty -= NewBreakPenalty;
2162 Token->reflow(NextLineIndex, Whitespaces);
2167 BreakableToken::Split SplitAfterLastLine =
2168 Token->getSplitAfterLastLine(TailOffset);
2169 if (SplitAfterLastLine.first != StringRef::npos) {
2170 LLVM_DEBUG(llvm::dbgs() <<
"Replacing whitespace after last line.\n");
2174 Penalty += Style.PenaltyExcessCharacter *
2175 (ContentStartColumn + RemainingTokenColumns - ColumnLimit);
2178 Token->replaceWhitespaceAfterLastLine(TailOffset, SplitAfterLastLine,
2180 ContentStartColumn =
2181 Token->getContentStartColumn(Token->getLineCount() - 1,
true);
2182 RemainingTokenColumns = Token->getRemainingLength(
2183 Token->getLineCount() - 1,
2184 TailOffset + SplitAfterLastLine.first + SplitAfterLastLine.second,
2185 ContentStartColumn);
2188 State.
Column = ContentStartColumn + RemainingTokenColumns -
2191 if (BreakInserted) {
2195 if (Current.
isNot(TT_LineComment)) {
2196 for (
unsigned i = 0, e = State.
Stack.size(); i != e; ++i)
2197 State.
Stack[i].BreakBeforeParameter =
true;
2200 if (Current.
is(TT_BlockComment))
2203 State.
Stack.back().LastSpace = StartColumn;
2206 Token->updateNextToken(State);
2208 return {Penalty, Exceeded};
2216 bool ContinuationIndenter::nextIsMultilineString(
const LineState &State) {
2223 if (Current.
TokenText.startswith(
"R\""))
2230 if (Style.ColumnLimit != 0 && Style.BreakStringLiterals &&
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
Defines the SourceManager interface.
Declares BreakableToken, BreakableStringLiteral, BreakableComment, BreakableBlockComment and Breakabl...
bool isLiteral() const
Return true if this is a "literal", like a numeric constant, string, etc.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Token - This structure provides full information about a lexed token.
__DEVICE__ int max(int __a, int __b)
Language
The language for the input, used to select and validate the language standard and possible actions...
WhitespaceManager class manages whitespace around tokens and their replacements.
const AnnotatedLine * Line
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Defines and computes precedence levels for binary/ternary operators.
SourceLocation getEnd() const
Encodes a location in the source.
IdentifierInfo * getIdentifierInfo() const
unsigned getSpellingColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const
Dataflow Directional Tag Classes.
tok::PPKeywordKind getPPKeywordID() const
Return the preprocessor keyword ID for this identifier.
__DEVICE__ int min(int __a, int __b)
This file implements an indenter that manages the indentation of continuations.
SourceLocation getBegin() const
This class handles loading and caching of source files into memory.