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) ||
477 (Current.
is(tok::kw_operator) && !Previous.
is(tok::coloncolon))) &&
478 !Previous.
is(tok::kw_template) && State.
Stack.back().BreakBeforeParameter)
485 Previous.
is(tok::l_brace) && !Current.
isOneOf(tok::r_brace, tok::comment))
488 if (Current.
is(tok::lessless) &&
489 ((Previous.
is(tok::identifier) && Previous.
TokenText ==
"endl") ||
505 unsigned ExtraSpaces) {
508 assert(!State.
Stack.empty());
511 if ((Current.
is(TT_ImplicitStringLiteral) &&
514 tok::pp_not_keyword))) {
522 unsigned StartColumn =
524 assert(EndColumn >= StartColumn);
525 State.
Column += EndColumn - StartColumn;
527 moveStateToNextToken(State, DryRun,
false);
531 unsigned Penalty = 0;
533 Penalty = addTokenOnNewLine(State, DryRun);
535 addTokenOnCurrentLine(State, DryRun, ExtraSpaces);
537 return moveStateToNextToken(State, DryRun, Newline) + Penalty;
540 void ContinuationIndenter::addTokenOnCurrentLine(
LineState &
State,
bool DryRun,
541 unsigned ExtraSpaces) {
544 if (Current.
is(tok::equal) &&
546 State.
Stack.back().VariablePos == 0) {
557 State.
Stack.back().LastSpace = State.
Stack.back().VariablePos;
563 int PPColumnCorrection = 0;
564 if (Style.IndentPPDirectives == FormatStyle::PPDIS_AfterHash &&
574 if (Style.UseTab != FormatStyle::UT_Never)
575 PPColumnCorrection = -1;
580 State.
Column + Spaces + PPColumnCorrection);
584 if (Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma &&
585 Current.
is(TT_InheritanceColon))
586 State.
Stack.back().NoLineBreak =
true;
587 if (Style.BreakInheritanceList == FormatStyle::BILS_AfterColon &&
588 Previous.
is(TT_InheritanceColon))
589 State.
Stack.back().NoLineBreak =
true;
591 if (Current.
is(TT_SelectorName) &&
592 !State.
Stack.back().ObjCSelectorNameFound) {
595 State.
Stack.back().Indent);
598 State.
Stack.back().AlignColons =
false;
602 State.
Stack.back().ColonPos = FirstColonPos;
609 Previous.
isOneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) &&
610 State.
Column > getNewLineColumn(State) &&
612 tok::kw_for, tok::kw_while, tok::kw_switch)) &&
622 State.
Stack.back().NoLineBreak =
true;
623 if (Previous.
is(TT_TemplateString) && Previous.
opensScope())
624 State.
Stack.back().NoLineBreak =
true;
631 State.
Stack.back().NoLineBreak =
true;
633 State.
Column > getNewLineColumn(State))
634 State.
Stack.back().ContainsUnwrappedBuilder =
true;
636 if (Current.
is(TT_LambdaArrow) && Style.Language == FormatStyle::LK_Java)
637 State.
Stack.back().NoLineBreak =
true;
647 State.
Stack.back().NoLineBreak =
true;
654 if (!Current.
is(tok::comment) && P &&
655 (P->
isOneOf(TT_BinaryOperator, tok::comma) ||
656 (P->
is(TT_ConditionalExpr) && P->
is(tok::colon))) &&
657 !P->
isOneOf(TT_OverloadedOperator, TT_CtorInitializerComma) &&
661 bool BreakBeforeOperator =
663 (P->
is(TT_BinaryOperator) &&
664 Style.BreakBeforeBinaryOperators != FormatStyle::BOS_None) ||
665 (P->
is(TT_ConditionalExpr) && Style.BreakBeforeTernaryOperators);
669 bool HasTwoOperands =
671 if ((!BreakBeforeOperator && !(HasTwoOperands && Style.
AlignOperands)) ||
672 (!State.
Stack.back().LastOperatorWrapped && BreakBeforeOperator))
673 State.
Stack.back().NoLineBreakInOperand =
true;
677 if (Current.
isNot(tok::comment) && Previous.
is(tok::l_paren) &&
684 State.
Stack.back().NestedBlockIndent = State.
Column;
685 }
else if (!Current.
isOneOf(tok::comment, tok::caret) &&
686 ((Previous.
is(tok::comma) &&
687 !Previous.
is(TT_OverloadedOperator)) ||
688 (Previous.
is(tok::colon) && Previous.
is(TT_ObjCMethodExpr)))) {
690 }
else if (Previous.
is(TT_CtorInitializerColon) &&
691 Style.BreakConstructorInitializers ==
692 FormatStyle::BCIS_AfterColon) {
695 }
else if ((Previous.
isOneOf(TT_BinaryOperator, TT_ConditionalExpr,
696 TT_CtorInitializerColon)) &&
704 if (Style.BreakBeforeBinaryOperators == FormatStyle::BOS_None)
706 }
else if (Previous.
is(TT_InheritanceColon)) {
715 bool HasTrailingCall =
false;
720 if (HasTrailingCall && State.
Stack.size() > 1 &&
721 State.
Stack[State.
Stack.size() - 2].CallContinuation == 0)
726 unsigned ContinuationIndenter::addTokenOnNewLine(
LineState &State,
733 unsigned Penalty = 0;
738 NextNonComment = &Current;
741 if (!State.
Stack.back().ContainsLineBreak)
743 State.
Stack.back().ContainsLineBreak =
true;
750 if (NextNonComment->
is(tok::lessless) &&
751 State.
Stack.back().FirstLessLess == 0 &&
752 (State.
Column <= Style.ColumnLimit / 3 ||
753 State.
Stack.back().BreakBeforeParameter))
754 Penalty += Style.PenaltyBreakFirstLessLess;
756 State.
Column = getNewLineColumn(State);
768 if (!Current.
is(TT_LambdaArrow) &&
769 (Style.Language != FormatStyle::LK_JavaScript ||
771 !PreviousNonComment->
is(tok::equal) ||
773 State.
Stack.back().NestedBlockIndent = State.
Column;
776 if (State.
Stack.back().CallContinuation == 0)
777 State.
Stack.back().CallContinuation = State.
Column;
778 }
else if (NextNonComment->
is(TT_SelectorName)) {
779 if (!State.
Stack.back().ObjCSelectorNameFound) {
781 State.
Stack.back().AlignColons =
false;
783 State.
Stack.back().ColonPos =
787 : State.
Stack.back().Indent) +
791 }
else if (State.
Stack.back().AlignColons &&
795 }
else if (PreviousNonComment && PreviousNonComment->
is(tok::colon) &&
796 PreviousNonComment->
isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) {
806 if (State.
Stack.size() > 1)
807 State.
Stack[State.
Stack.size() - 2].LastSpace =
809 Style.ContinuationIndentWidth;
812 if ((PreviousNonComment &&
813 PreviousNonComment->
isOneOf(tok::comma, tok::semi) &&
814 !State.
Stack.back().AvoidBinPacking) ||
815 Previous.
is(TT_BinaryOperator))
816 State.
Stack.back().BreakBeforeParameter =
false;
817 if (PreviousNonComment &&
818 PreviousNonComment->
isOneOf(TT_TemplateCloser, TT_JavaAnnotation) &&
820 State.
Stack.back().BreakBeforeParameter =
false;
821 if (NextNonComment->
is(tok::question) ||
822 (PreviousNonComment && PreviousNonComment->
is(tok::question)))
823 State.
Stack.back().BreakBeforeParameter =
true;
825 State.
Stack.back().BreakBeforeParameter =
false;
828 unsigned MaxEmptyLinesToKeep = Style.MaxEmptyLinesToKeep + 1;
836 MaxEmptyLinesToKeep = 1;
840 bool ContinuePPDirective =
843 ContinuePPDirective);
848 if (Current.
is(tok::lessless))
852 State.
Stack.back().LastSpace += 3;
859 bool NestedBlockSpecialCase =
860 !Style.isCpp() && Current.
is(tok::r_brace) && State.
Stack.size() > 1 &&
861 State.
Stack[State.
Stack.size() - 2].NestedBlockInlined;
862 if (!NestedBlockSpecialCase)
863 for (
unsigned i = 0, e = State.
Stack.size() - 1;
i != e; ++
i)
864 State.
Stack[
i].BreakBeforeParameter =
true;
866 if (PreviousNonComment &&
867 !PreviousNonComment->
isOneOf(tok::comma, tok::colon, tok::semi) &&
868 (PreviousNonComment->
isNot(TT_TemplateCloser) ||
871 TT_BinaryOperator, TT_FunctionAnnotationRParen, TT_JavaAnnotation,
872 TT_LeadingJavaAnnotation) &&
874 State.
Stack.back().BreakBeforeParameter =
true;
878 if (PreviousNonComment &&
879 (PreviousNonComment->
isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
881 State.
Stack.back().BreakBeforeClosingBrace =
true;
883 if (State.
Stack.back().AvoidBinPacking) {
888 bool PreviousIsBreakingCtorInitializerColon =
889 Previous.
is(TT_CtorInitializerColon) &&
890 Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon;
891 if (!(Previous.
isOneOf(tok::l_paren, tok::l_brace, TT_BinaryOperator) ||
892 PreviousIsBreakingCtorInitializerColon) ||
893 (!Style.AllowAllParametersOfDeclarationOnNextLine &&
897 (!Style.AllowAllConstructorInitializersOnNextLine &&
898 PreviousIsBreakingCtorInitializerColon) ||
899 Previous.
is(TT_DictLiteral))
900 State.
Stack.back().BreakBeforeParameter =
true;
905 if (PreviousIsBreakingCtorInitializerColon &&
906 Style.AllowAllConstructorInitializersOnNextLine)
907 State.
Stack.back().BreakBeforeParameter =
false;
913 unsigned ContinuationIndenter::getNewLineColumn(
const LineState &State) {
919 unsigned ContinuationIndent =
921 Style.ContinuationIndentWidth;
925 NextNonComment = &Current;
928 if (Style.Language == FormatStyle::LK_Java &&
931 State.
Stack.back().Indent + Style.ContinuationIndentWidth);
935 : State.
Stack.back().Indent;
936 if ((Current.
isOneOf(tok::r_brace, tok::r_square) ||
937 (Current.
is(tok::greater) &&
938 (Style.Language == FormatStyle::LK_Proto ||
939 Style.Language == FormatStyle::LK_TextProto))) &&
940 State.
Stack.size() > 1) {
942 return State.
Stack[State.
Stack.size() - 2].NestedBlockIndent;
945 return State.
Stack[State.
Stack.size() - 2].LastSpace;
963 if (Current.
is(tok::r_paren) && State.
Stack.size() > 1 &&
965 Current.
Next->
isOneOf(tok::semi, tok::kw_const, tok::l_brace)))
966 return State.
Stack[State.
Stack.size() - 2].LastSpace;
967 if (NextNonComment->
is(TT_TemplateString) && NextNonComment->
closesScope())
968 return State.
Stack[State.
Stack.size() - 2].LastSpace;
969 if (Current.
is(tok::identifier) && Current.
Next &&
970 (Current.
Next->
is(TT_DictLiteral) ||
971 ((Style.Language == FormatStyle::LK_Proto ||
972 Style.Language == FormatStyle::LK_TextProto) &&
974 return State.
Stack.back().Indent;
975 if (NextNonComment->
is(TT_ObjCStringLiteral) &&
980 if (NextNonComment->
is(tok::lessless) &&
981 State.
Stack.back().FirstLessLess != 0)
982 return State.
Stack.back().FirstLessLess;
984 if (State.
Stack.back().CallContinuation == 0)
985 return ContinuationIndent;
986 return State.
Stack.back().CallContinuation;
988 if (State.
Stack.back().QuestionColumn != 0 &&
989 ((NextNonComment->
is(tok::colon) &&
990 NextNonComment->
is(TT_ConditionalExpr)) ||
991 Previous.
is(TT_ConditionalExpr)))
992 return State.
Stack.back().QuestionColumn;
993 if (Previous.
is(tok::comma) && State.
Stack.back().VariablePos != 0)
994 return State.
Stack.back().VariablePos;
995 if ((PreviousNonComment &&
996 (PreviousNonComment->ClosesTemplateDeclaration ||
997 PreviousNonComment->isOneOf(
998 TT_AttributeParen, TT_AttributeSquare, TT_FunctionAnnotationRParen,
999 TT_JavaAnnotation, TT_LeadingJavaAnnotation))) ||
1000 (!Style.IndentWrappedFunctionNames &&
1001 NextNonComment->
isOneOf(tok::kw_operator, TT_FunctionDeclarationName)))
1003 if (NextNonComment->
is(TT_SelectorName)) {
1004 if (!State.
Stack.back().ObjCSelectorNameFound) {
1005 unsigned MinIndent = State.
Stack.back().Indent;
1008 State.
FirstIndent + Style.ContinuationIndentWidth);
1023 if (!State.
Stack.back().AlignColons)
1024 return State.
Stack.back().Indent;
1027 return State.
Stack.back().Indent;
1029 if (NextNonComment->
is(tok::colon) && NextNonComment->
is(TT_ObjCMethodExpr))
1030 return State.
Stack.back().ColonPos;
1031 if (NextNonComment->
is(TT_ArraySubscriptLSquare)) {
1032 if (State.
Stack.back().StartOfArraySubscripts != 0)
1033 return State.
Stack.back().StartOfArraySubscripts;
1034 return ContinuationIndent;
1039 if (NextNonComment->
is(tok::identifier) && NextNonComment->
FakeRParens == 0 &&
1040 NextNonComment->
Next && NextNonComment->
Next->
is(TT_ObjCMethodExpr))
1041 return State.
Stack.back().Indent;
1043 if (NextNonComment->
isOneOf(TT_StartOfName, TT_PointerOrReference) ||
1044 Previous.
isOneOf(tok::coloncolon, tok::equal, TT_JsTypeColon))
1045 return ContinuationIndent;
1046 if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
1047 PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral))
1048 return ContinuationIndent;
1049 if (NextNonComment->
is(TT_CtorInitializerComma))
1050 return State.
Stack.back().Indent;
1051 if (PreviousNonComment && PreviousNonComment->is(TT_CtorInitializerColon) &&
1052 Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon)
1053 return State.
Stack.back().Indent;
1054 if (PreviousNonComment && PreviousNonComment->is(TT_InheritanceColon) &&
1055 Style.BreakInheritanceList == FormatStyle::BILS_AfterColon)
1056 return State.
Stack.back().Indent;
1057 if (NextNonComment->
isOneOf(TT_CtorInitializerColon, TT_InheritanceColon,
1058 TT_InheritanceComma))
1059 return State.
FirstIndent + Style.ConstructorInitializerIndentWidth;
1061 !Current.
isOneOf(tok::colon, tok::comment))
1062 return ContinuationIndent;
1063 if (Current.
is(TT_ProtoExtensionLSquare))
1064 return State.
Stack.back().Indent;
1065 if (State.
Stack.back().Indent == State.
FirstIndent && PreviousNonComment &&
1066 !PreviousNonComment->isOneOf(tok::r_brace, TT_CtorInitializerComma))
1069 return State.
Stack.back().Indent + Style.ContinuationIndentWidth;
1070 return State.
Stack.back().Indent;
1073 unsigned ContinuationIndenter::moveStateToNextToken(
LineState &State,
1074 bool DryRun,
bool Newline) {
1075 assert(State.
Stack.size());
1078 if (Current.isOneOf(tok::comma, TT_BinaryOperator))
1079 State.
Stack.back().NoLineBreakInOperand =
false;
1080 if (Current.is(TT_InheritanceColon))
1081 State.
Stack.back().AvoidBinPacking =
true;
1082 if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) {
1083 if (State.
Stack.back().FirstLessLess == 0)
1086 State.
Stack.back().LastOperatorWrapped = Newline;
1088 if (Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless))
1089 State.
Stack.back().LastOperatorWrapped = Newline;
1090 if (Current.is(TT_ConditionalExpr) && Current.Previous &&
1091 !Current.Previous->is(TT_ConditionalExpr))
1092 State.
Stack.back().LastOperatorWrapped = Newline;
1093 if (Current.is(TT_ArraySubscriptLSquare) &&
1094 State.
Stack.back().StartOfArraySubscripts == 0)
1095 State.
Stack.back().StartOfArraySubscripts = State.
Column;
1096 if (Style.BreakBeforeTernaryOperators && Current.is(tok::question))
1098 if (!Style.BreakBeforeTernaryOperators && Current.isNot(tok::colon)) {
1102 if (Previous && Previous->
is(tok::question))
1105 if (!Current.opensScope() && !Current.closesScope() &&
1106 !Current.is(TT_PointerOrReference))
1109 if (Current.isMemberAccess())
1110 State.
Stack.back().StartOfFunctionCall =
1111 !Current.NextOperator ? 0 : State.
Column;
1112 if (Current.is(TT_SelectorName))
1113 State.
Stack.back().ObjCSelectorNameFound =
true;
1114 if (Current.is(TT_CtorInitializerColon) &&
1115 Style.BreakConstructorInitializers != FormatStyle::BCIS_AfterColon) {
1121 State.
Stack.back().Indent =
1123 (Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma
1126 State.
Stack.back().NestedBlockIndent = State.
Stack.back().Indent;
1127 if (Style.ConstructorInitializerAllOnOneLineOrOnePerLine) {
1128 State.
Stack.back().AvoidBinPacking =
true;
1129 State.
Stack.back().BreakBeforeParameter =
1130 !Style.AllowAllConstructorInitializersOnNextLine;
1132 State.
Stack.back().BreakBeforeParameter =
false;
1135 if (Current.is(TT_CtorInitializerColon) &&
1136 Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon) {
1137 State.
Stack.back().Indent =
1138 State.
FirstIndent + Style.ConstructorInitializerIndentWidth;
1139 State.
Stack.back().NestedBlockIndent = State.
Stack.back().Indent;
1140 if (Style.ConstructorInitializerAllOnOneLineOrOnePerLine)
1141 State.
Stack.back().AvoidBinPacking =
true;
1143 if (Current.is(TT_InheritanceColon))
1144 State.
Stack.back().Indent =
1145 State.
FirstIndent + Style.ConstructorInitializerIndentWidth;
1146 if (Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline)
1147 State.
Stack.back().NestedBlockIndent =
1148 State.
Column + Current.ColumnWidth + 1;
1149 if (Current.isOneOf(TT_LambdaLSquare, TT_LambdaArrow))
1161 if (Current.isNot(tok::comment) && Previous &&
1162 Previous->
isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&
1163 !Previous->
is(TT_DictLiteral) && State.
Stack.size() > 1 &&
1164 !State.
Stack.back().HasMultipleNestedBlocks) {
1165 if (State.
Stack[State.
Stack.size() - 2].NestedBlockInlined && Newline)
1166 for (
unsigned i = 0, e = State.
Stack.size() - 1;
i != e; ++
i)
1167 State.
Stack[
i].NoLineBreak =
true;
1168 State.
Stack[State.
Stack.size() - 2].NestedBlockInlined =
false;
1171 (Previous->
isOneOf(tok::l_paren, tok::comma, tok::colon) ||
1172 Previous->
isOneOf(TT_BinaryOperator, TT_ConditionalExpr)) &&
1173 !Previous->
isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)) {
1174 State.
Stack.back().NestedBlockInlined =
1179 moveStatePastFakeLParens(State, Newline);
1180 moveStatePastScopeCloser(State);
1181 bool AllowBreak = !State.
Stack.back().NoLineBreak &&
1182 !State.
Stack.back().NoLineBreakInOperand;
1183 moveStatePastScopeOpener(State, Newline);
1184 moveStatePastFakeRParens(State);
1192 else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) &&
1193 !Current.isStringLiteral())
1196 State.
Column += Current.ColumnWidth;
1200 handleEndOfLine(Current, State, DryRun, AllowBreak, Newline);
1203 Current.Role->formatFromToken(State,
this, DryRun);
1209 if (Previous && Previous->
Role)
1210 Penalty += Previous->
Role->formatAfterToken(State,
this, DryRun);
1215 void ContinuationIndenter::moveStatePastFakeLParens(
LineState &State,
1223 bool SkipFirstExtraIndent =
1225 Previous->
isOneOf(tok::semi, tok::kw_return) ||
1228 Previous->
is(TT_ObjCMethodExpr)));
1234 NewParenState.
Tok =
nullptr;
1249 (!Previous || Previous->
isNot(tok::kw_return) ||
1250 (Style.Language != FormatStyle::LK_Java && *I > 0)) &&
1255 State.
Stack.back().LastSpace);
1276 NewParenState.
Indent += Style.ContinuationIndentWidth;
1279 State.
Stack.push_back(NewParenState);
1280 SkipFirstExtraIndent =
false;
1284 void ContinuationIndenter::moveStatePastFakeRParens(
LineState &State) {
1286 unsigned VariablePos = State.
Stack.back().VariablePos;
1287 if (State.
Stack.size() == 1) {
1291 State.
Stack.pop_back();
1292 State.
Stack.back().VariablePos = VariablePos;
1296 void ContinuationIndenter::moveStatePastScopeOpener(
LineState &State,
1303 moveStateToNewBlock(State);
1308 unsigned LastSpace = State.
Stack.back().LastSpace;
1309 bool AvoidBinPacking;
1310 bool BreakBeforeParameter =
false;
1311 unsigned NestedBlockIndent =
std::max(State.
Stack.back().StartOfFunctionCall,
1312 State.
Stack.back().NestedBlockIndent);
1313 if (Current.
isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
1316 NewIndent = Style.IndentWidth +
1319 NewIndent = State.
Stack.back().LastSpace + Style.ContinuationIndentWidth;
1325 AvoidBinPacking = EndsInComma || Current.
is(TT_DictLiteral) ||
1326 Style.Language == FormatStyle::LK_Proto ||
1327 Style.Language == FormatStyle::LK_TextProto ||
1328 !Style.BinPackArguments ||
1330 NextNoComment->
isOneOf(TT_DesignatedInitializerPeriod,
1331 TT_DesignatedInitializerLSquare));
1332 BreakBeforeParameter = EndsInComma;
1334 NestedBlockIndent =
std::max(NestedBlockIndent, State.
Column + 1);
1336 NewIndent = Style.ContinuationIndentWidth +
1338 State.
Stack.back().StartOfFunctionCall);
1356 bool ObjCBinPackProtocolList =
1357 (Style.ObjCBinPackProtocolList == FormatStyle::BPS_Auto &&
1358 Style.BinPackParameters) ||
1359 Style.ObjCBinPackProtocolList == FormatStyle::BPS_Always;
1361 bool BinPackDeclaration =
1366 (Style.Language == FormatStyle::LK_JavaScript && EndsInComma) ||
1369 (Style.ExperimentalAutoDetectBinPacking &&
1371 (!BinPackInconclusiveFunctions &&
1375 if (Style.ColumnLimit) {
1380 BreakBeforeParameter =
true;
1388 BreakBeforeParameter =
true;
1395 if (Style.Language == FormatStyle::LK_JavaScript && EndsInComma)
1396 BreakBeforeParameter =
true;
1403 !Current.
isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) &&
1404 (State.
Stack.back().NoLineBreak ||
1405 State.
Stack.back().NoLineBreakInOperand ||
1406 (Current.
is(TT_TemplateOpener) &&
1407 State.
Stack.back().ContainsUnwrappedBuilder));
1408 State.
Stack.push_back(
1409 ParenState(&Current, NewIndent, LastSpace, AvoidBinPacking, NoLineBreak));
1410 State.
Stack.back().NestedBlockIndent = NestedBlockIndent;
1411 State.
Stack.back().BreakBeforeParameter = BreakBeforeParameter;
1413 State.
Stack.back().IsInsideObjCArrayLiteral =
1414 Current.
is(TT_ArrayInitializerLSquare) && Current.
Previous &&
1418 void ContinuationIndenter::moveStatePastScopeCloser(
LineState &State) {
1425 if (State.
Stack.size() > 1 &&
1426 (Current.
isOneOf(tok::r_paren, tok::r_square, TT_TemplateString) ||
1429 (Current.
is(tok::greater) && Current.
is(TT_DictLiteral))))
1430 State.
Stack.pop_back();
1445 if (CurrentScopeOpener.
is(TT_ObjCMethodExpr) &&
1447 int NecessarySpaceInLine =
1452 State.
Stack.back().BreakBeforeParameter =
false;
1456 if (Current.
is(tok::r_square)) {
1459 if (NextNonComment && NextNonComment->
isNot(tok::l_square))
1460 State.
Stack.back().StartOfArraySubscripts = 0;
1464 void ContinuationIndenter::moveStateToNewBlock(
LineState &State) {
1465 unsigned NestedBlockIndent = State.
Stack.back().NestedBlockIndent;
1467 unsigned NewIndent =
1468 NestedBlockIndent + (State.
NextToken->
is(TT_ObjCBlockLBrace)
1469 ? Style.ObjCBlockIndentWidth
1470 : Style.IndentWidth);
1472 State.
Stack.back().LastSpace,
1475 State.
Stack.back().NestedBlockIndent = NestedBlockIndent;
1476 State.
Stack.back().BreakBeforeParameter =
true;
1482 size_t LastNewlinePos = Text.find_last_of(
"\n");
1483 if (LastNewlinePos == StringRef::npos) {
1484 return StartColumn +
1488 0, TabWidth, Encoding);
1492 unsigned ContinuationIndenter::reformatRawStringLiteral(
1494 const FormatStyle &RawStringStyle,
bool DryRun,
bool Newline) {
1497 StringRef NewDelimiter =
1499 if (NewDelimiter.empty() || OldDelimiter.empty())
1500 NewDelimiter = OldDelimiter;
1503 unsigned OldPrefixSize = 3 + OldDelimiter.size();
1504 unsigned OldSuffixSize = 2 + OldDelimiter.size();
1507 std::string RawText =
1508 Current.
TokenText.substr(OldPrefixSize).drop_back(OldSuffixSize);
1509 if (NewDelimiter != OldDelimiter) {
1512 std::string CanonicalDelimiterSuffix = (
")" + NewDelimiter +
"\"").str();
1513 if (StringRef(RawText).contains(CanonicalDelimiterSuffix))
1514 NewDelimiter = OldDelimiter;
1517 unsigned NewPrefixSize = 3 + NewDelimiter.size();
1518 unsigned NewSuffixSize = 2 + NewDelimiter.size();
1521 unsigned FirstStartColumn = StartColumn + NewPrefixSize;
1532 bool ContentStartsOnNewline = Current.
TokenText[OldPrefixSize] ==
'\n';
1554 unsigned CurrentIndent =
1555 (!Newline && Current.
Next && Current.
Next->
is(tok::r_paren))
1556 ? State.
Stack.back().NestedBlockIndent
1557 : State.
Stack.back().Indent;
1558 unsigned NextStartColumn = ContentStartsOnNewline
1559 ? CurrentIndent + Style.IndentWidth
1570 unsigned LastStartColumn =
1571 Current.
NewlinesBefore ? FirstStartColumn - NewPrefixSize : CurrentIndent;
1575 FirstStartColumn, NextStartColumn, LastStartColumn,
"<stdin>",
1581 return addMultilineToken(Current, State);
1584 if (NewDelimiter != OldDelimiter) {
1590 SourceMgr, PrefixDelimiterStart, OldDelimiter.size(), NewDelimiter));
1593 <<
"Failed to update the prefix delimiter of a raw string: " 1600 1 - OldDelimiter.size());
1602 SourceMgr, SuffixDelimiterStart, OldDelimiter.size(), NewDelimiter));
1605 <<
"Failed to update the suffix delimiter of a raw string: " 1616 llvm::errs() <<
"Failed to reformat raw string: " 1622 *NewCode, FirstStartColumn, Style.TabWidth, Encoding);
1623 State.
Column = RawLastLineEndColumn + NewSuffixSize;
1627 unsigned PrefixExcessCharacters =
1628 StartColumn + NewPrefixSize > Style.ColumnLimit
1629 ? StartColumn + NewPrefixSize - Style.ColumnLimit
1632 ContentStartsOnNewline || (NewCode->find(
'\n') != std::string::npos);
1635 for (
unsigned i = 0, e = State.
Stack.size();
i != e; ++
i)
1636 State.
Stack[
i].BreakBeforeParameter =
true;
1638 return Fixes.second + PrefixExcessCharacters * Style.PenaltyExcessCharacter;
1641 unsigned ContinuationIndenter::addMultilineToken(
const FormatToken &Current,
1644 for (
unsigned i = 0, e = State.
Stack.size();
i != e; ++
i)
1645 State.
Stack[
i].BreakBeforeParameter =
true;
1647 unsigned ColumnsUsed = State.
Column;
1653 return Style.PenaltyExcessCharacter * (ColumnsUsed -
getColumnLimit(State));
1657 unsigned ContinuationIndenter::handleEndOfLine(
const FormatToken &Current,
1659 bool AllowBreak,
bool Newline) {
1660 unsigned Penalty = 0;
1663 auto RawStringStyle = getRawStringStyle(Current, State);
1664 if (RawStringStyle && !Current.
Finalized) {
1665 Penalty = reformatRawStringLiteral(Current, State, *RawStringStyle, DryRun,
1670 Penalty = addMultilineToken(Current, State);
1677 bool Strict =
false;
1680 bool Exceeded =
false;
1681 std::tie(Penalty, Exceeded) = breakProtrudingToken(
1682 Current, State, AllowBreak,
true, Strict);
1687 unsigned StrictPenalty =
1688 breakProtrudingToken(Current, StrictState, AllowBreak,
1691 Strict = StrictPenalty <= Penalty;
1693 Penalty = StrictPenalty;
1694 State = StrictState;
1700 breakProtrudingToken(Current, OriginalState, AllowBreak,
false,
1706 Penalty += Style.PenaltyExcessCharacter * ExcessCharacters;
1716 if (!
Tok || !
Tok->
is(tok::l_paren))
1721 if (
Tok->
is(TT_TemplateCloser)) {
1726 if (!
Tok || !
Tok->
is(tok::identifier))
1732 ContinuationIndenter::getRawStringStyle(
const FormatToken &Current,
1740 if (!RawStringStyle && Delimiter->empty())
1743 if (!RawStringStyle)
1746 return RawStringStyle;
1749 std::unique_ptr<BreakableToken>
1750 ContinuationIndenter::createBreakableToken(
const FormatToken &Current,
1757 if (Style.Language == FormatStyle::LK_Java ||
1758 Style.Language == FormatStyle::LK_JavaScript || Style.isCSharp() ||
1759 !Style.BreakStringLiterals || !AllowBreak)
1775 if (State.
Stack.back().IsInsideObjCArrayLiteral) {
1786 if ((Text.endswith(Postfix =
"\"") &&
1787 (Text.startswith(Prefix =
"@\"") || Text.startswith(Prefix =
"\"") ||
1788 Text.startswith(Prefix =
"u\"") || Text.startswith(Prefix =
"U\"") ||
1789 Text.startswith(Prefix =
"u8\"") ||
1790 Text.startswith(Prefix =
"L\""))) ||
1791 (Text.startswith(Prefix =
"_T(\"") && Text.endswith(Postfix =
"\")"))) {
1799 return llvm::make_unique<BreakableStringLiteral>(
1800 Current, StartColumn, Prefix, Postfix, UnbreakableTailLength,
1803 }
else if (Current.
is(TT_BlockComment)) {
1804 if (!Style.ReflowComments ||
1811 return llvm::make_unique<BreakableBlockComment>(
1814 }
else if (Current.
is(TT_LineComment) &&
1817 if (!Style.ReflowComments ||
1818 CommentPragmasRegex.match(Current.
TokenText.substr(2)) ||
1821 return llvm::make_unique<BreakableLineCommentSection>(
1823 false, Encoding, Style);
1828 std::pair<unsigned, bool>
1829 ContinuationIndenter::breakProtrudingToken(
const FormatToken &Current,
1831 bool DryRun,
bool Strict) {
1832 std::unique_ptr<const BreakableToken>
Token =
1833 createBreakableToken(Current, State, AllowBreak);
1836 assert(Token->getLineCount() > 0);
1838 if (Current.
is(TT_LineComment)) {
1840 ColumnLimit = Style.ColumnLimit;
1848 ? Style.PenaltyBreakString
1849 : Style.PenaltyBreakComment;
1852 bool Exceeded =
false;
1854 bool BreakInserted = Token->introducesBreakBeforeToken();
1857 bool NewBreakBefore =
false;
1861 bool Reflow =
false;
1864 unsigned TailOffset = 0;
1866 unsigned ContentStartColumn =
1867 Token->getContentStartColumn(0,
false);
1869 unsigned RemainingTokenColumns =
1870 Token->getRemainingLength(0, TailOffset, ContentStartColumn);
1873 Token->adaptStartOfLine(0, Whitespaces);
1875 unsigned ContentIndent = 0;
1876 unsigned Penalty = 0;
1877 LLVM_DEBUG(llvm::dbgs() <<
"Breaking protruding token at column " 1878 << StartColumn <<
".\n");
1879 for (
unsigned LineIndex = 0, EndIndex = Token->getLineCount();
1880 LineIndex != EndIndex; ++LineIndex) {
1881 LLVM_DEBUG(llvm::dbgs()
1882 <<
" Line: " << LineIndex <<
" (Reflow: " << Reflow <<
")\n");
1883 NewBreakBefore =
false;
1887 bool TryReflow = Reflow;
1889 while (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
1890 LLVM_DEBUG(llvm::dbgs() <<
" Over limit, need: " 1891 << (ContentStartColumn + RemainingTokenColumns)
1892 <<
", space: " << ColumnLimit
1893 <<
", reflown prefix: " << ContentStartColumn
1894 <<
", offset in line: " << TailOffset <<
"\n");
1899 BreakableToken::Split
Split =
1900 Token->getSplit(LineIndex, TailOffset, ColumnLimit,
1901 ContentStartColumn, CommentPragmasRegex);
1902 if (Split.first == StringRef::npos) {
1905 if (LineIndex < EndIndex - 1)
1908 Penalty += Style.PenaltyExcessCharacter *
1909 (ContentStartColumn + RemainingTokenColumns - ColumnLimit);
1910 LLVM_DEBUG(llvm::dbgs() <<
" No break opportunity.\n");
1913 assert(Split.first != 0);
1915 if (Token->supportsReflow()) {
1935 unsigned ToSplitColumns = Token->getRangeLength(
1936 LineIndex, TailOffset, Split.first, ContentStartColumn);
1937 LLVM_DEBUG(llvm::dbgs() <<
" ToSplit: " << ToSplitColumns <<
"\n");
1939 BreakableToken::Split NextSplit = Token->getSplit(
1940 LineIndex, TailOffset + Split.first + Split.second, ColumnLimit,
1941 ContentStartColumn + ToSplitColumns + 1, CommentPragmasRegex);
1944 unsigned ToNextSplitColumns = 0;
1945 if (NextSplit.first == StringRef::npos) {
1946 ToNextSplitColumns = Token->getRemainingLength(LineIndex, TailOffset,
1947 ContentStartColumn);
1949 ToNextSplitColumns = Token->getRangeLength(
1950 LineIndex, TailOffset,
1951 Split.first + Split.second + NextSplit.first, ContentStartColumn);
1955 ToNextSplitColumns =
1956 Token->getLengthAfterCompression(ToNextSplitColumns, Split);
1957 LLVM_DEBUG(llvm::dbgs()
1958 <<
" ContentStartColumn: " << ContentStartColumn <<
"\n");
1959 LLVM_DEBUG(llvm::dbgs()
1960 <<
" ToNextSplit: " << ToNextSplitColumns <<
"\n");
1963 bool ContinueOnLine =
1964 ContentStartColumn + ToNextSplitColumns <= ColumnLimit;
1965 unsigned ExcessCharactersPenalty = 0;
1966 if (!ContinueOnLine && !Strict) {
1969 ExcessCharactersPenalty =
1970 (ContentStartColumn + ToNextSplitColumns - ColumnLimit) *
1971 Style.PenaltyExcessCharacter;
1972 LLVM_DEBUG(llvm::dbgs()
1973 <<
" Penalty excess: " << ExcessCharactersPenalty
1974 <<
"\n break : " << NewBreakPenalty <<
"\n");
1975 if (ExcessCharactersPenalty < NewBreakPenalty) {
1977 ContinueOnLine =
true;
1980 if (ContinueOnLine) {
1981 LLVM_DEBUG(llvm::dbgs() <<
" Continuing on line...\n");
1986 Token->compressWhitespace(LineIndex, TailOffset, Split,
1989 ContentStartColumn += ToSplitColumns + 1;
1990 Penalty += ExcessCharactersPenalty;
1991 TailOffset += Split.first + Split.second;
1992 RemainingTokenColumns = Token->getRemainingLength(
1993 LineIndex, TailOffset, ContentStartColumn);
1997 LLVM_DEBUG(llvm::dbgs() <<
" Breaking...\n");
2002 ContentIndent = Token->getContentIndent(LineIndex);
2003 LLVM_DEBUG(llvm::dbgs()
2004 <<
" ContentIndent: " << ContentIndent <<
"\n");
2005 ContentStartColumn = ContentIndent + Token->getContentStartColumn(
2008 unsigned NewRemainingTokenColumns = Token->getRemainingLength(
2009 LineIndex, TailOffset + Split.first + Split.second,
2010 ContentStartColumn);
2011 if (NewRemainingTokenColumns == 0) {
2014 ContentStartColumn =
2015 Token->getContentStartColumn(LineIndex,
true);
2016 NewRemainingTokenColumns = Token->getRemainingLength(
2017 LineIndex, TailOffset + Split.first + Split.second,
2018 ContentStartColumn);
2024 if (NewRemainingTokenColumns == RemainingTokenColumns) {
2028 assert(NewRemainingTokenColumns < RemainingTokenColumns);
2030 LLVM_DEBUG(llvm::dbgs() <<
" Breaking at: " << TailOffset + Split.first
2031 <<
", " << Split.second <<
"\n");
2033 Token->insertBreak(LineIndex, TailOffset, Split, ContentIndent,
2036 Penalty += NewBreakPenalty;
2037 TailOffset += Split.first + Split.second;
2038 RemainingTokenColumns = NewRemainingTokenColumns;
2039 BreakInserted =
true;
2040 NewBreakBefore =
true;
2044 if (LineIndex + 1 != EndIndex) {
2045 unsigned NextLineIndex = LineIndex + 1;
2064 ContentStartColumn += RemainingTokenColumns + 1;
2068 BreakableToken::Split SplitBeforeNext =
2069 Token->getReflowSplit(NextLineIndex, CommentPragmasRegex);
2070 LLVM_DEBUG(llvm::dbgs()
2071 <<
" Size of reflown text: " << ContentStartColumn
2072 <<
"\n Potential reflow split: ");
2073 if (SplitBeforeNext.first != StringRef::npos) {
2074 LLVM_DEBUG(llvm::dbgs() << SplitBeforeNext.first <<
", " 2075 << SplitBeforeNext.second <<
"\n");
2076 TailOffset = SplitBeforeNext.first + SplitBeforeNext.second;
2079 RemainingTokenColumns = Token->getRemainingLength(
2080 NextLineIndex, TailOffset, ContentStartColumn);
2082 if (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
2083 LLVM_DEBUG(llvm::dbgs()
2084 <<
" Over limit after reflow, need: " 2085 << (ContentStartColumn + RemainingTokenColumns)
2086 <<
", space: " << ColumnLimit
2087 <<
", reflown prefix: " << ContentStartColumn
2088 <<
", offset in line: " << TailOffset <<
"\n");
2093 BreakableToken::Split
Split =
2094 Token->getSplit(NextLineIndex, TailOffset, ColumnLimit,
2095 ContentStartColumn, CommentPragmasRegex);
2096 if (Split.first == StringRef::npos) {
2097 LLVM_DEBUG(llvm::dbgs() <<
" Did not find later break\n");
2103 unsigned ToSplitColumns = Token->getRangeLength(
2104 NextLineIndex, TailOffset, Split.first, ContentStartColumn);
2105 if (ContentStartColumn + ToSplitColumns > ColumnLimit) {
2106 LLVM_DEBUG(llvm::dbgs() <<
" Next split protrudes, need: " 2107 << (ContentStartColumn + ToSplitColumns)
2108 <<
", space: " << ColumnLimit);
2109 unsigned ExcessCharactersPenalty =
2110 (ContentStartColumn + ToSplitColumns - ColumnLimit) *
2111 Style.PenaltyExcessCharacter;
2112 if (NewBreakPenalty < ExcessCharactersPenalty) {
2119 LLVM_DEBUG(llvm::dbgs() <<
"not found.\n");
2127 ContentStartColumn =
2128 Token->getContentStartColumn(NextLineIndex,
false);
2129 RemainingTokenColumns = Token->getRemainingLength(
2130 NextLineIndex, TailOffset, ContentStartColumn);
2133 Token->adaptStartOfLine(NextLineIndex, Whitespaces);
2148 if (NewBreakBefore) {
2149 assert(Penalty >= NewBreakPenalty);
2150 Penalty -= NewBreakPenalty;
2153 Token->reflow(NextLineIndex, Whitespaces);
2158 BreakableToken::Split SplitAfterLastLine =
2159 Token->getSplitAfterLastLine(TailOffset);
2160 if (SplitAfterLastLine.first != StringRef::npos) {
2161 LLVM_DEBUG(llvm::dbgs() <<
"Replacing whitespace after last line.\n");
2165 Penalty += Style.PenaltyExcessCharacter *
2166 (ContentStartColumn + RemainingTokenColumns - ColumnLimit);
2169 Token->replaceWhitespaceAfterLastLine(TailOffset, SplitAfterLastLine,
2171 ContentStartColumn =
2172 Token->getContentStartColumn(Token->getLineCount() - 1,
true);
2173 RemainingTokenColumns = Token->getRemainingLength(
2174 Token->getLineCount() - 1,
2175 TailOffset + SplitAfterLastLine.first + SplitAfterLastLine.second,
2176 ContentStartColumn);
2179 State.
Column = ContentStartColumn + RemainingTokenColumns -
2182 if (BreakInserted) {
2186 if (Current.
isNot(TT_LineComment)) {
2187 for (
unsigned i = 0, e = State.
Stack.size();
i != e; ++
i)
2188 State.
Stack[
i].BreakBeforeParameter =
true;
2191 if (Current.
is(TT_BlockComment))
2194 State.
Stack.back().LastSpace = StartColumn;
2197 Token->updateNextToken(State);
2199 return {Penalty, Exceeded};
2207 bool ContinuationIndenter::nextIsMultilineString(
const LineState &State) {
2214 if (Current.
TokenText.startswith(
"R\""))
2221 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)
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.