22 #include "llvm/Support/Debug.h" 24 #define DEBUG_TYPE "format-indenter" 39 const std::vector<ParenState> &Stack) {
82 int MatchingStackIndex = Stack.size() - 1;
88 while (MatchingStackIndex >= 0 && Stack[MatchingStackIndex].Tok != LBrace)
90 return MatchingStackIndex >= 0 ? &Stack[MatchingStackIndex] :
nullptr;
99 tok::l_brace, TT_ArrayInitializerLSquare, tok::less)) {
124 if (Current.
is(TT_CtorInitializerComma) &&
130 ((Previous.
isNot(TT_CtorInitializerComma) ||
133 (Previous.
isNot(TT_InheritanceComma) ||
139 if (LessTok.
isNot(tok::less))
151 if (TokenText.size() < 5
152 || !TokenText.startswith(
"R\"") || !TokenText.endswith(
"\""))
158 size_t LParenPos = TokenText.substr(0, 19).find_first_of(
'(');
159 if (LParenPos == StringRef::npos)
161 StringRef Delimiter = TokenText.substr(2, LParenPos - 2);
164 size_t RParenPos = TokenText.size() - Delimiter.size() - 2;
165 if (TokenText[RParenPos] !=
')')
167 if (!TokenText.substr(RParenPos + 1).startswith(Delimiter))
178 if (Format.Language == Language)
179 return StringRef(Format.CanonicalDelimiter);
189 if (!LanguageStyle) {
192 RawStringFormat.Language, &PredefinedStyle)) {
194 PredefinedStyle.
Language = RawStringFormat.Language;
196 LanguageStyle = PredefinedStyle;
198 LanguageStyle->ColumnLimit = CodeStyle.
ColumnLimit;
199 for (StringRef Delimiter : RawStringFormat.Delimiters) {
202 for (StringRef EnclosingFunction : RawStringFormat.EnclosingFunctions) {
218 StringRef EnclosingFunction)
const {
230 bool BinPackInconclusiveFunctions)
231 : Style(Style), Keywords(Keywords), SourceMgr(SourceMgr),
232 Whitespaces(Whitespaces), Encoding(Encoding),
233 BinPackInconclusiveFunctions(BinPackInconclusiveFunctions),
234 CommentPragmasRegex(Style.CommentPragmas), RawStringFormats(Style) {}
237 unsigned FirstStartColumn,
243 State.
Column = FirstStartColumn;
245 State.
Column = FirstIndent;
268 State.
Stack.back().AvoidBinPacking =
true;
269 State.
Stack.back().BreakBeforeParameter =
true;
270 State.
Stack.back().AlignColons =
false;
274 moveStateToNextToken(State, DryRun,
false);
281 assert(&Previous == Current.
Previous);
306 if (Previous.
is(tok::l_brace) && State.
Stack.size() > 1 &&
307 State.
Stack[State.
Stack.size() - 2].NestedBlockInlined &&
308 State.
Stack[State.
Stack.size() - 2].HasMultipleNestedBlocks)
313 if (Current.
is(TT_FunctionDeclarationName) && State.
Column < 6) {
320 if (!Current.
isOneOf(TT_BinaryOperator, tok::comma) &&
321 State.
Stack.back().NoLineBreakInOperand)
324 if (Previous.
is(tok::l_square) && Previous.
is(TT_ObjCMethodExpr))
327 return !State.
Stack.back().NoLineBreak;
335 if (State.
Stack.back().BreakBeforeClosingBrace &&
342 Current.
startsSequence(TT_SelectorName, tok::colon, tok::caret)) {
346 (Previous.
is(TT_TemplateCloser) && Current.
is(TT_StartOfName) &&
354 Previous.
isNot(tok::question)) ||
356 Previous.
is(TT_ConditionalExpr))) &&
358 !Current.
isOneOf(tok::r_paren, tok::r_brace))
360 if (((Previous.
is(TT_DictLiteral) && Previous.
is(tok::l_brace)) ||
361 (Previous.
is(TT_ArrayInitializerLSquare) &&
369 const FormatToken &BreakConstructorInitializersToken =
373 if (BreakConstructorInitializersToken.
is(TT_CtorInitializerColon) &&
376 State.
Stack.back().BreakBeforeParameter) &&
382 if (Current.
is(TT_ObjCMethodExpr) && !Previous.
is(TT_SelectorName) &&
385 if (Current.
is(TT_SelectorName) && !Previous.
is(tok::at) &&
386 State.
Stack.back().ObjCSelectorNameFound &&
387 State.
Stack.back().BreakBeforeParameter)
390 unsigned NewLineColumn = getNewLineColumn(State);
393 (State.
Column > NewLineColumn ||
398 (State.
Stack.back().CallContinuation != 0 ||
399 State.
Stack.back().BreakBeforeParameter) &&
405 !(State.
Column <= NewLineColumn &&
415 if (State.
Column <= NewLineColumn)
421 !Previous.
isOneOf(tok::kw_return, tok::lessless, tok::at) &&
422 !Previous.
isOneOf(TT_InlineASMColon, TT_ConditionalExpr) &&
423 nextIsMultilineString(State))
444 bool LHSIsBinaryExpr =
448 State.
Stack.back().BreakBeforeParameter)
451 State.
Stack.back().BreakBeforeParameter) {
456 if (Current.
is(tok::lessless) && Current.
isNot(TT_OverloadedOperator) &&
457 State.
Stack.back().BreakBeforeParameter &&
458 State.
Stack.back().FirstLessLess == 0)
467 if (Previous.
is(TT_FunctionAnnotationRParen))
469 if (Previous.
is(TT_LeadingJavaAnnotation) && Current.
isNot(tok::l_paren) &&
470 Current.
isNot(TT_LeadingJavaAnnotation))
475 if ((Current.
is(TT_FunctionDeclarationName) ||
476 (Current.
is(tok::kw_operator) && !Previous.
is(tok::coloncolon))) &&
477 !Previous.
is(tok::kw_template) && State.
Stack.back().BreakBeforeParameter)
484 Previous.
is(tok::l_brace) && !Current.
isOneOf(tok::r_brace, tok::comment))
487 if (Current.
is(tok::lessless) &&
488 ((Previous.
is(tok::identifier) && Previous.
TokenText ==
"endl") ||
504 unsigned ExtraSpaces) {
507 assert(!State.
Stack.empty());
510 if ((Current.
is(TT_ImplicitStringLiteral) &&
513 tok::pp_not_keyword))) {
521 unsigned StartColumn =
523 assert(EndColumn >= StartColumn);
524 State.
Column += EndColumn - StartColumn;
526 moveStateToNextToken(State, DryRun,
false);
530 unsigned Penalty = 0;
532 Penalty = addTokenOnNewLine(State, DryRun);
534 addTokenOnCurrentLine(State, DryRun, ExtraSpaces);
536 return moveStateToNextToken(State, DryRun, Newline) + Penalty;
539 void ContinuationIndenter::addTokenOnCurrentLine(
LineState &
State,
bool DryRun,
540 unsigned ExtraSpaces) {
543 if (Current.
is(tok::equal) &&
545 State.
Stack.back().VariablePos == 0) {
556 State.
Stack.back().LastSpace = State.
Stack.back().VariablePos;
562 int PPColumnCorrection = 0;
574 PPColumnCorrection = -1;
579 State.
Column + Spaces + PPColumnCorrection);
584 Current.
is(TT_InheritanceColon))
585 State.
Stack.back().NoLineBreak =
true;
587 Previous.
is(TT_InheritanceColon))
588 State.
Stack.back().NoLineBreak =
true;
590 if (Current.
is(TT_SelectorName) &&
591 !State.
Stack.back().ObjCSelectorNameFound) {
594 State.
Stack.back().Indent);
597 State.
Stack.back().AlignColons =
false;
601 State.
Stack.back().ColonPos = FirstColonPos;
608 Previous.
isOneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) &&
609 State.
Column > getNewLineColumn(State) &&
611 tok::kw_for, tok::kw_while, tok::kw_switch)) &&
621 State.
Stack.back().NoLineBreak =
true;
622 if (Previous.
is(TT_TemplateString) && Previous.
opensScope())
623 State.
Stack.back().NoLineBreak =
true;
630 State.
Stack.back().NoLineBreak =
true;
632 State.
Column > getNewLineColumn(State))
633 State.
Stack.back().ContainsUnwrappedBuilder =
true;
636 State.
Stack.back().NoLineBreak =
true;
646 State.
Stack.back().NoLineBreak =
true;
653 if (!Current.
is(tok::comment) && P &&
654 (P->
isOneOf(TT_BinaryOperator, tok::comma) ||
655 (P->
is(TT_ConditionalExpr) && P->
is(tok::colon))) &&
656 !P->
isOneOf(TT_OverloadedOperator, TT_CtorInitializerComma) &&
660 bool BreakBeforeOperator =
662 (P->
is(TT_BinaryOperator) &&
668 bool HasTwoOperands =
670 if ((!BreakBeforeOperator && !(HasTwoOperands && Style.
AlignOperands)) ||
671 (!State.
Stack.back().LastOperatorWrapped && BreakBeforeOperator))
672 State.
Stack.back().NoLineBreakInOperand =
true;
676 if (Current.
isNot(tok::comment) && Previous.
is(tok::l_paren) &&
683 State.
Stack.back().NestedBlockIndent = State.
Column;
684 }
else if (!Current.
isOneOf(tok::comment, tok::caret) &&
685 ((Previous.
is(tok::comma) &&
686 !Previous.
is(TT_OverloadedOperator)) ||
687 (Previous.
is(tok::colon) && Previous.
is(TT_ObjCMethodExpr)))) {
689 }
else if (Previous.
is(TT_CtorInitializerColon) &&
694 }
else if ((Previous.
isOneOf(TT_BinaryOperator, TT_ConditionalExpr,
695 TT_CtorInitializerColon)) &&
704 }
else if (Previous.
is(TT_InheritanceColon)) {
713 bool HasTrailingCall =
false;
718 if (HasTrailingCall && State.
Stack.size() > 1 &&
719 State.
Stack[State.
Stack.size() - 2].CallContinuation == 0)
724 unsigned ContinuationIndenter::addTokenOnNewLine(
LineState &State,
731 unsigned Penalty = 0;
736 NextNonComment = &Current;
739 if (!State.
Stack.back().ContainsLineBreak)
741 State.
Stack.back().ContainsLineBreak =
true;
748 if (NextNonComment->
is(tok::lessless) &&
749 State.
Stack.back().FirstLessLess == 0 &&
751 State.
Stack.back().BreakBeforeParameter))
754 State.
Column = getNewLineColumn(State);
766 if (!Current.
is(TT_LambdaArrow) &&
769 !PreviousNonComment->
is(tok::equal) ||
771 State.
Stack.back().NestedBlockIndent = State.
Column;
774 if (State.
Stack.back().CallContinuation == 0)
775 State.
Stack.back().CallContinuation = State.
Column;
776 }
else if (NextNonComment->
is(TT_SelectorName)) {
777 if (!State.
Stack.back().ObjCSelectorNameFound) {
779 State.
Stack.back().AlignColons =
false;
781 State.
Stack.back().ColonPos =
785 : State.
Stack.back().Indent) +
789 }
else if (State.
Stack.back().AlignColons &&
793 }
else if (PreviousNonComment && PreviousNonComment->
is(tok::colon) &&
794 PreviousNonComment->
isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) {
804 if (State.
Stack.size() > 1)
805 State.
Stack[State.
Stack.size() - 2].LastSpace =
810 if ((PreviousNonComment &&
811 PreviousNonComment->
isOneOf(tok::comma, tok::semi) &&
812 !State.
Stack.back().AvoidBinPacking) ||
813 Previous.
is(TT_BinaryOperator))
814 State.
Stack.back().BreakBeforeParameter =
false;
815 if (PreviousNonComment &&
816 PreviousNonComment->
isOneOf(TT_TemplateCloser, TT_JavaAnnotation) &&
818 State.
Stack.back().BreakBeforeParameter =
false;
819 if (NextNonComment->
is(tok::question) ||
820 (PreviousNonComment && PreviousNonComment->
is(tok::question)))
821 State.
Stack.back().BreakBeforeParameter =
true;
823 State.
Stack.back().BreakBeforeParameter =
false;
834 MaxEmptyLinesToKeep = 1;
838 bool ContinuePPDirective =
841 ContinuePPDirective);
846 if (Current.
is(tok::lessless))
850 State.
Stack.back().LastSpace += 3;
857 bool NestedBlockSpecialCase =
858 !Style.
isCpp() && Current.
is(tok::r_brace) && State.
Stack.size() > 1 &&
859 State.
Stack[State.
Stack.size() - 2].NestedBlockInlined;
860 if (!NestedBlockSpecialCase)
861 for (
unsigned i = 0, e = State.
Stack.size() - 1; i != e; ++i)
862 State.
Stack[i].BreakBeforeParameter =
true;
864 if (PreviousNonComment &&
865 !PreviousNonComment->
isOneOf(tok::comma, tok::colon, tok::semi) &&
866 (PreviousNonComment->
isNot(TT_TemplateCloser) ||
869 TT_BinaryOperator, TT_FunctionAnnotationRParen, TT_JavaAnnotation,
870 TT_LeadingJavaAnnotation) &&
872 State.
Stack.back().BreakBeforeParameter =
true;
876 if (PreviousNonComment &&
877 (PreviousNonComment->
isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
879 State.
Stack.back().BreakBeforeClosingBrace =
true;
881 if (State.
Stack.back().AvoidBinPacking) {
885 if (!Previous.
isOneOf(tok::l_paren, tok::l_brace, TT_BinaryOperator) ||
888 Previous.
is(TT_DictLiteral))
889 State.
Stack.back().BreakBeforeParameter =
true;
895 unsigned ContinuationIndenter::getNewLineColumn(
const LineState &State) {
901 unsigned ContinuationIndent =
907 NextNonComment = &Current;
917 : State.
Stack.back().Indent;
918 if ((Current.
isOneOf(tok::r_brace, tok::r_square) ||
919 (Current.
is(tok::greater) &&
922 State.
Stack.size() > 1) {
924 return State.
Stack[State.
Stack.size() - 2].NestedBlockIndent;
927 return State.
Stack[State.
Stack.size() - 2].LastSpace;
940 if (Current.
is(tok::r_paren) && State.
Stack.size() > 1 &&
942 return State.
Stack[State.
Stack.size() - 2].LastSpace;
943 if (NextNonComment->
is(TT_TemplateString) && NextNonComment->
closesScope())
944 return State.
Stack[State.
Stack.size() - 2].LastSpace;
945 if (Current.
is(tok::identifier) && Current.
Next &&
946 (Current.
Next->
is(TT_DictLiteral) ||
950 return State.
Stack.back().Indent;
951 if (NextNonComment->
is(TT_ObjCStringLiteral) &&
956 if (NextNonComment->
is(tok::lessless) &&
957 State.
Stack.back().FirstLessLess != 0)
958 return State.
Stack.back().FirstLessLess;
960 if (State.
Stack.back().CallContinuation == 0)
961 return ContinuationIndent;
962 return State.
Stack.back().CallContinuation;
964 if (State.
Stack.back().QuestionColumn != 0 &&
965 ((NextNonComment->
is(tok::colon) &&
966 NextNonComment->
is(TT_ConditionalExpr)) ||
967 Previous.
is(TT_ConditionalExpr)))
968 return State.
Stack.back().QuestionColumn;
969 if (Previous.
is(tok::comma) && State.
Stack.back().VariablePos != 0)
970 return State.
Stack.back().VariablePos;
971 if ((PreviousNonComment &&
972 (PreviousNonComment->ClosesTemplateDeclaration ||
973 PreviousNonComment->isOneOf(
974 TT_AttributeParen, TT_AttributeSquare, TT_FunctionAnnotationRParen,
975 TT_JavaAnnotation, TT_LeadingJavaAnnotation))) ||
977 NextNonComment->
isOneOf(tok::kw_operator, TT_FunctionDeclarationName)))
979 if (NextNonComment->
is(TT_SelectorName)) {
980 if (!State.
Stack.back().ObjCSelectorNameFound) {
981 unsigned MinIndent = State.
Stack.back().Indent;
999 if (!State.
Stack.back().AlignColons)
1000 return State.
Stack.back().Indent;
1003 return State.
Stack.back().Indent;
1005 if (NextNonComment->
is(tok::colon) && NextNonComment->
is(TT_ObjCMethodExpr))
1006 return State.
Stack.back().ColonPos;
1007 if (NextNonComment->
is(TT_ArraySubscriptLSquare)) {
1008 if (State.
Stack.back().StartOfArraySubscripts != 0)
1009 return State.
Stack.back().StartOfArraySubscripts;
1010 return ContinuationIndent;
1015 if (NextNonComment->
is(tok::identifier) && NextNonComment->
FakeRParens == 0 &&
1016 NextNonComment->
Next && NextNonComment->
Next->
is(TT_ObjCMethodExpr))
1017 return State.
Stack.back().Indent;
1019 if (NextNonComment->
isOneOf(TT_StartOfName, TT_PointerOrReference) ||
1020 Previous.
isOneOf(tok::coloncolon, tok::equal, TT_JsTypeColon))
1021 return ContinuationIndent;
1022 if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
1023 PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral))
1024 return ContinuationIndent;
1025 if (NextNonComment->
is(TT_CtorInitializerComma))
1026 return State.
Stack.back().Indent;
1027 if (PreviousNonComment && PreviousNonComment->is(TT_CtorInitializerColon) &&
1029 return State.
Stack.back().Indent;
1030 if (PreviousNonComment && PreviousNonComment->is(TT_InheritanceColon) &&
1032 return State.
Stack.back().Indent;
1033 if (NextNonComment->
isOneOf(TT_CtorInitializerColon, TT_InheritanceColon,
1034 TT_InheritanceComma))
1037 !Current.
isOneOf(tok::colon, tok::comment))
1038 return ContinuationIndent;
1039 if (Current.
is(TT_ProtoExtensionLSquare))
1040 return State.
Stack.back().Indent;
1041 if (State.
Stack.back().Indent == State.
FirstIndent && PreviousNonComment &&
1042 PreviousNonComment->isNot(tok::r_brace))
1046 return State.
Stack.back().Indent;
1049 unsigned ContinuationIndenter::moveStateToNextToken(
LineState &State,
1050 bool DryRun,
bool Newline) {
1051 assert(State.
Stack.size());
1054 if (Current.isOneOf(tok::comma, TT_BinaryOperator))
1055 State.
Stack.back().NoLineBreakInOperand =
false;
1056 if (Current.is(TT_InheritanceColon))
1057 State.
Stack.back().AvoidBinPacking =
true;
1058 if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) {
1059 if (State.
Stack.back().FirstLessLess == 0)
1062 State.
Stack.back().LastOperatorWrapped = Newline;
1064 if (Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless))
1065 State.
Stack.back().LastOperatorWrapped = Newline;
1066 if (Current.is(TT_ConditionalExpr) && Current.Previous &&
1067 !Current.Previous->is(TT_ConditionalExpr))
1068 State.
Stack.back().LastOperatorWrapped = Newline;
1069 if (Current.is(TT_ArraySubscriptLSquare) &&
1070 State.
Stack.back().StartOfArraySubscripts == 0)
1071 State.
Stack.back().StartOfArraySubscripts = State.
Column;
1078 if (Previous && Previous->
is(tok::question))
1081 if (!Current.opensScope() && !Current.closesScope() &&
1082 !Current.is(TT_PointerOrReference))
1085 if (Current.isMemberAccess())
1086 State.
Stack.back().StartOfFunctionCall =
1087 !Current.NextOperator ? 0 : State.
Column;
1088 if (Current.is(TT_SelectorName))
1089 State.
Stack.back().ObjCSelectorNameFound =
true;
1090 if (Current.is(TT_CtorInitializerColon) &&
1097 State.
Stack.back().Indent =
1102 State.
Stack.back().NestedBlockIndent = State.
Stack.back().Indent;
1104 State.
Stack.back().AvoidBinPacking =
true;
1105 State.
Stack.back().BreakBeforeParameter =
false;
1107 if (Current.is(TT_CtorInitializerColon) &&
1109 State.
Stack.back().Indent =
1111 State.
Stack.back().NestedBlockIndent = State.
Stack.back().Indent;
1113 State.
Stack.back().AvoidBinPacking =
true;
1115 if (Current.is(TT_InheritanceColon))
1116 State.
Stack.back().Indent =
1118 if (Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline)
1119 State.
Stack.back().NestedBlockIndent =
1120 State.
Column + Current.ColumnWidth + 1;
1121 if (Current.isOneOf(TT_LambdaLSquare, TT_LambdaArrow))
1133 if (Current.isNot(tok::comment) && Previous &&
1134 Previous->
isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&
1135 !Previous->
is(TT_DictLiteral) && State.
Stack.size() > 1) {
1136 if (State.
Stack[State.
Stack.size() - 2].NestedBlockInlined && Newline)
1137 for (
unsigned i = 0, e = State.
Stack.size() - 1; i != e; ++i)
1138 State.
Stack[i].NoLineBreak =
true;
1139 State.
Stack[State.
Stack.size() - 2].NestedBlockInlined =
false;
1142 (Previous->
isOneOf(tok::l_paren, tok::comma, tok::colon) ||
1143 Previous->
isOneOf(TT_BinaryOperator, TT_ConditionalExpr)) &&
1144 !Previous->
isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)) {
1145 State.
Stack.back().NestedBlockInlined =
1150 moveStatePastFakeLParens(State, Newline);
1151 moveStatePastScopeCloser(State);
1152 bool AllowBreak = !State.
Stack.back().NoLineBreak &&
1153 !State.
Stack.back().NoLineBreakInOperand;
1154 moveStatePastScopeOpener(State, Newline);
1155 moveStatePastFakeRParens(State);
1161 else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) &&
1162 !Current.isStringLiteral())
1165 State.
Column += Current.ColumnWidth;
1169 handleEndOfLine(Current, State, DryRun, AllowBreak);
1172 Current.Role->formatFromToken(State,
this, DryRun);
1178 if (Previous && Previous->
Role)
1179 Penalty += Previous->
Role->formatAfterToken(State,
this, DryRun);
1184 void ContinuationIndenter::moveStatePastFakeLParens(
LineState &State,
1192 bool SkipFirstExtraIndent =
1194 Previous->
isOneOf(tok::semi, tok::kw_return) ||
1197 Previous->
is(TT_ObjCMethodExpr)));
1203 NewParenState.
Tok =
nullptr;
1218 (!Previous || Previous->
isNot(tok::kw_return) ||
1224 State.
Stack.back().LastSpace);
1248 State.
Stack.push_back(NewParenState);
1249 SkipFirstExtraIndent =
false;
1253 void ContinuationIndenter::moveStatePastFakeRParens(
LineState &State) {
1255 unsigned VariablePos = State.
Stack.back().VariablePos;
1256 if (State.
Stack.size() == 1) {
1260 State.
Stack.pop_back();
1261 State.
Stack.back().VariablePos = VariablePos;
1265 void ContinuationIndenter::moveStatePastScopeOpener(
LineState &State,
1272 moveStateToNewBlock(State);
1277 unsigned LastSpace = State.
Stack.back().LastSpace;
1278 bool AvoidBinPacking;
1279 bool BreakBeforeParameter =
false;
1280 unsigned NestedBlockIndent =
std::max(State.
Stack.back().StartOfFunctionCall,
1281 State.
Stack.back().NestedBlockIndent);
1282 if (Current.
isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
1294 AvoidBinPacking = EndsInComma || Current.
is(TT_DictLiteral) ||
1299 NextNoComment->
isOneOf(TT_DesignatedInitializerPeriod,
1300 TT_DesignatedInitializerLSquare));
1301 BreakBeforeParameter = EndsInComma;
1303 NestedBlockIndent =
std::max(NestedBlockIndent, State.
Column + 1);
1307 State.
Stack.back().StartOfFunctionCall);
1325 bool ObjCBinPackProtocolList =
1330 bool BinPackDeclaration =
1340 (!BinPackInconclusiveFunctions &&
1349 BreakBeforeParameter =
true;
1357 BreakBeforeParameter =
true;
1365 BreakBeforeParameter =
true;
1372 !Current.
isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) &&
1373 (State.
Stack.back().NoLineBreak ||
1374 State.
Stack.back().NoLineBreakInOperand ||
1375 (Current.
is(TT_TemplateOpener) &&
1376 State.
Stack.back().ContainsUnwrappedBuilder));
1377 State.
Stack.push_back(
1378 ParenState(&Current, NewIndent, LastSpace, AvoidBinPacking, NoLineBreak));
1379 State.
Stack.back().NestedBlockIndent = NestedBlockIndent;
1380 State.
Stack.back().BreakBeforeParameter = BreakBeforeParameter;
1382 State.
Stack.back().IsInsideObjCArrayLiteral =
1383 Current.
is(TT_ArrayInitializerLSquare) && Current.
Previous &&
1387 void ContinuationIndenter::moveStatePastScopeCloser(
LineState &State) {
1394 if (State.
Stack.size() > 1 &&
1395 (Current.
isOneOf(tok::r_paren, tok::r_square, TT_TemplateString) ||
1398 (Current.
is(tok::greater) && Current.
is(TT_DictLiteral))))
1399 State.
Stack.pop_back();
1414 if (CurrentScopeOpener.
is(TT_ObjCMethodExpr) &&
1416 int NecessarySpaceInLine =
1421 State.
Stack.back().BreakBeforeParameter =
false;
1425 if (Current.
is(tok::r_square)) {
1428 if (NextNonComment && NextNonComment->
isNot(tok::l_square))
1429 State.
Stack.back().StartOfArraySubscripts = 0;
1433 void ContinuationIndenter::moveStateToNewBlock(
LineState &State) {
1434 unsigned NestedBlockIndent = State.
Stack.back().NestedBlockIndent;
1436 unsigned NewIndent =
1437 NestedBlockIndent + (State.
NextToken->
is(TT_ObjCBlockLBrace)
1441 State.
Stack.back().LastSpace,
1444 State.
Stack.back().NestedBlockIndent = NestedBlockIndent;
1445 State.
Stack.back().BreakBeforeParameter =
true;
1451 size_t LastNewlinePos = Text.find_last_of(
"\n");
1452 if (LastNewlinePos == StringRef::npos) {
1453 return StartColumn +
1457 0, TabWidth, Encoding);
1461 unsigned ContinuationIndenter::reformatRawStringLiteral(
1466 StringRef NewDelimiter =
1468 if (NewDelimiter.empty() || OldDelimiter.empty())
1469 NewDelimiter = OldDelimiter;
1472 unsigned OldPrefixSize = 3 + OldDelimiter.size();
1473 unsigned OldSuffixSize = 2 + OldDelimiter.size();
1476 std::string RawText =
1477 Current.
TokenText.substr(OldPrefixSize).drop_back(OldSuffixSize);
1478 if (NewDelimiter != OldDelimiter) {
1481 std::string CanonicalDelimiterSuffix = (
")" + NewDelimiter +
"\"").str();
1482 if (StringRef(RawText).contains(CanonicalDelimiterSuffix))
1483 NewDelimiter = OldDelimiter;
1486 unsigned NewPrefixSize = 3 + NewDelimiter.size();
1487 unsigned NewSuffixSize = 2 + NewDelimiter.size();
1490 unsigned FirstStartColumn = StartColumn + NewPrefixSize;
1501 bool ContentStartsOnNewline = Current.
TokenText[OldPrefixSize] ==
'\n';
1502 unsigned NextStartColumn =
1503 ContentStartsOnNewline
1516 ? FirstStartColumn - NewPrefixSize
1517 : State.
Stack.back().NestedBlockIndent;
1521 FirstStartColumn, NextStartColumn, LastStartColumn,
"<stdin>",
1531 if (NewDelimiter != OldDelimiter) {
1537 SourceMgr, PrefixDelimiterStart, OldDelimiter.size(), NewDelimiter));
1540 <<
"Failed to update the prefix delimiter of a raw string: " 1547 1 - OldDelimiter.size());
1549 SourceMgr, SuffixDelimiterStart, OldDelimiter.size(), NewDelimiter));
1552 <<
"Failed to update the suffix delimiter of a raw string: " 1563 llvm::errs() <<
"Failed to reformat raw string: " 1569 *NewCode, FirstStartColumn, Style.
TabWidth, Encoding);
1570 State.
Column = RawLastLineEndColumn + NewSuffixSize;
1574 unsigned PrefixExcessCharacters =
1576 StartColumn + NewPrefixSize - Style.
ColumnLimit : 0;
1580 unsigned ContinuationIndenter::addMultilineToken(
const FormatToken &Current,
1583 for (
unsigned i = 0, e = State.
Stack.size(); i != e; ++i)
1584 State.
Stack[i].BreakBeforeParameter =
true;
1586 unsigned ColumnsUsed = State.
Column;
1596 unsigned ContinuationIndenter::handleEndOfLine(
const FormatToken &Current,
1599 unsigned Penalty = 0;
1602 auto RawStringStyle = getRawStringStyle(Current, State);
1603 if (RawStringStyle && !Current.
Finalized) {
1604 Penalty = reformatRawStringLiteral(Current, State, *RawStringStyle, DryRun);
1608 Penalty = addMultilineToken(Current, State);
1615 bool Strict =
false;
1618 bool Exceeded =
false;
1619 std::tie(Penalty, Exceeded) = breakProtrudingToken(
1620 Current, State, AllowBreak,
true, Strict);
1625 unsigned StrictPenalty =
1626 breakProtrudingToken(Current, StrictState, AllowBreak,
1629 Strict = StrictPenalty <= Penalty;
1631 Penalty = StrictPenalty;
1632 State = StrictState;
1638 breakProtrudingToken(Current, OriginalState, AllowBreak,
false,
1654 if (!
Tok || !
Tok->
is(tok::l_paren))
1659 if (
Tok->
is(TT_TemplateCloser)) {
1664 if (!
Tok || !
Tok->
is(tok::identifier))
1670 ContinuationIndenter::getRawStringStyle(
const FormatToken &Current,
1678 if (!RawStringStyle && Delimiter->empty())
1681 if (!RawStringStyle)
1684 return RawStringStyle;
1687 std::unique_ptr<BreakableToken> ContinuationIndenter::createBreakableToken(
1712 if (State.
Stack.back().IsInsideObjCArrayLiteral) {
1723 if ((Text.endswith(Postfix =
"\"") &&
1724 (Text.startswith(Prefix =
"@\"") || Text.startswith(Prefix =
"\"") ||
1725 Text.startswith(Prefix =
"u\"") || Text.startswith(Prefix =
"U\"") ||
1726 Text.startswith(Prefix =
"u8\"") ||
1727 Text.startswith(Prefix =
"L\""))) ||
1728 (Text.startswith(Prefix =
"_T(\"") && Text.endswith(Postfix =
"\")"))) {
1736 return llvm::make_unique<BreakableStringLiteral>(
1737 Current, StartColumn, Prefix, Postfix, UnbreakableTailLength,
1740 }
else if (Current.
is(TT_BlockComment)) {
1748 return llvm::make_unique<BreakableBlockComment>(
1751 }
else if (Current.
is(TT_LineComment) &&
1755 CommentPragmasRegex.match(Current.
TokenText.substr(2)) ||
1758 return llvm::make_unique<BreakableLineCommentSection>(
1760 false, Encoding, Style);
1765 std::pair<unsigned, bool>
1766 ContinuationIndenter::breakProtrudingToken(
const FormatToken &Current,
1768 bool DryRun,
bool Strict) {
1769 std::unique_ptr<const BreakableToken>
Token =
1770 createBreakableToken(Current, State, AllowBreak);
1773 assert(Token->getLineCount() > 0);
1775 if (Current.
is(TT_LineComment)) {
1789 bool Exceeded =
false;
1791 bool BreakInserted = Token->introducesBreakBeforeToken();
1794 bool NewBreakBefore =
false;
1798 bool Reflow =
false;
1801 unsigned TailOffset = 0;
1803 unsigned ContentStartColumn =
1804 Token->getContentStartColumn(0,
false);
1806 unsigned RemainingTokenColumns =
1807 Token->getRemainingLength(0, TailOffset, ContentStartColumn);
1810 Token->adaptStartOfLine(0, Whitespaces);
1812 unsigned ContentIndent = 0;
1813 unsigned Penalty = 0;
1814 LLVM_DEBUG(llvm::dbgs() <<
"Breaking protruding token at column " 1815 << StartColumn <<
".\n");
1816 for (
unsigned LineIndex = 0, EndIndex = Token->getLineCount();
1817 LineIndex != EndIndex; ++LineIndex) {
1818 LLVM_DEBUG(llvm::dbgs()
1819 <<
" Line: " << LineIndex <<
" (Reflow: " << Reflow <<
")\n");
1820 NewBreakBefore =
false;
1824 bool TryReflow = Reflow;
1826 while (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
1827 LLVM_DEBUG(llvm::dbgs() <<
" Over limit, need: " 1828 << (ContentStartColumn + RemainingTokenColumns)
1829 <<
", space: " << ColumnLimit
1830 <<
", reflown prefix: " << ContentStartColumn
1831 <<
", offset in line: " << TailOffset <<
"\n");
1836 BreakableToken::Split Split =
1837 Token->getSplit(LineIndex, TailOffset, ColumnLimit,
1838 ContentStartColumn, CommentPragmasRegex);
1839 if (Split.first == StringRef::npos) {
1842 if (LineIndex < EndIndex - 1)
1845 (ContentStartColumn + RemainingTokenColumns - ColumnLimit);
1846 LLVM_DEBUG(llvm::dbgs() <<
" No break opportunity.\n");
1849 assert(Split.first != 0);
1851 if (Token->supportsReflow()) {
1871 unsigned ToSplitColumns = Token->getRangeLength(
1872 LineIndex, TailOffset, Split.first, ContentStartColumn);
1873 LLVM_DEBUG(llvm::dbgs() <<
" ToSplit: " << ToSplitColumns <<
"\n");
1875 BreakableToken::Split NextSplit = Token->getSplit(
1876 LineIndex, TailOffset + Split.first + Split.second, ColumnLimit,
1877 ContentStartColumn + ToSplitColumns + 1, CommentPragmasRegex);
1880 unsigned ToNextSplitColumns = 0;
1881 if (NextSplit.first == StringRef::npos) {
1882 ToNextSplitColumns = Token->getRemainingLength(LineIndex, TailOffset,
1883 ContentStartColumn);
1885 ToNextSplitColumns = Token->getRangeLength(
1886 LineIndex, TailOffset,
1887 Split.first + Split.second + NextSplit.first, ContentStartColumn);
1891 ToNextSplitColumns =
1892 Token->getLengthAfterCompression(ToNextSplitColumns, Split);
1893 LLVM_DEBUG(llvm::dbgs()
1894 <<
" ContentStartColumn: " << ContentStartColumn <<
"\n");
1895 LLVM_DEBUG(llvm::dbgs()
1896 <<
" ToNextSplit: " << ToNextSplitColumns <<
"\n");
1899 bool ContinueOnLine =
1900 ContentStartColumn + ToNextSplitColumns <= ColumnLimit;
1901 unsigned ExcessCharactersPenalty = 0;
1902 if (!ContinueOnLine && !Strict) {
1905 ExcessCharactersPenalty =
1906 (ContentStartColumn + ToNextSplitColumns - ColumnLimit) *
1908 LLVM_DEBUG(llvm::dbgs()
1909 <<
" Penalty excess: " << ExcessCharactersPenalty
1910 <<
"\n break : " << NewBreakPenalty <<
"\n");
1911 if (ExcessCharactersPenalty < NewBreakPenalty) {
1913 ContinueOnLine =
true;
1916 if (ContinueOnLine) {
1917 LLVM_DEBUG(llvm::dbgs() <<
" Continuing on line...\n");
1922 Token->compressWhitespace(LineIndex, TailOffset, Split,
1925 ContentStartColumn += ToSplitColumns + 1;
1926 Penalty += ExcessCharactersPenalty;
1927 TailOffset += Split.first + Split.second;
1928 RemainingTokenColumns = Token->getRemainingLength(
1929 LineIndex, TailOffset, ContentStartColumn);
1933 LLVM_DEBUG(llvm::dbgs() <<
" Breaking...\n");
1938 ContentIndent = Token->getContentIndent(LineIndex);
1939 LLVM_DEBUG(llvm::dbgs()
1940 <<
" ContentIndent: " << ContentIndent <<
"\n");
1941 ContentStartColumn = ContentIndent + Token->getContentStartColumn(
1944 unsigned NewRemainingTokenColumns = Token->getRemainingLength(
1945 LineIndex, TailOffset + Split.first + Split.second,
1946 ContentStartColumn);
1947 if (NewRemainingTokenColumns == 0) {
1950 ContentStartColumn =
1951 Token->getContentStartColumn(LineIndex,
true);
1952 NewRemainingTokenColumns = Token->getRemainingLength(
1953 LineIndex, TailOffset + Split.first + Split.second,
1954 ContentStartColumn);
1960 if (NewRemainingTokenColumns == RemainingTokenColumns) {
1964 assert(NewRemainingTokenColumns < RemainingTokenColumns);
1966 LLVM_DEBUG(llvm::dbgs() <<
" Breaking at: " << TailOffset + Split.first
1967 <<
", " << Split.second <<
"\n");
1969 Token->insertBreak(LineIndex, TailOffset, Split, ContentIndent,
1972 Penalty += NewBreakPenalty;
1973 TailOffset += Split.first + Split.second;
1974 RemainingTokenColumns = NewRemainingTokenColumns;
1975 BreakInserted =
true;
1976 NewBreakBefore =
true;
1980 if (LineIndex + 1 != EndIndex) {
1981 unsigned NextLineIndex = LineIndex + 1;
2000 ContentStartColumn += RemainingTokenColumns + 1;
2004 BreakableToken::Split SplitBeforeNext =
2005 Token->getReflowSplit(NextLineIndex, CommentPragmasRegex);
2006 LLVM_DEBUG(llvm::dbgs()
2007 <<
" Size of reflown text: " << ContentStartColumn
2008 <<
"\n Potential reflow split: ");
2009 if (SplitBeforeNext.first != StringRef::npos) {
2010 LLVM_DEBUG(llvm::dbgs() << SplitBeforeNext.first <<
", " 2011 << SplitBeforeNext.second <<
"\n");
2012 TailOffset = SplitBeforeNext.first + SplitBeforeNext.second;
2015 RemainingTokenColumns = Token->getRemainingLength(
2016 NextLineIndex, TailOffset, ContentStartColumn);
2018 if (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
2019 LLVM_DEBUG(llvm::dbgs()
2020 <<
" Over limit after reflow, need: " 2021 << (ContentStartColumn + RemainingTokenColumns)
2022 <<
", space: " << ColumnLimit
2023 <<
", reflown prefix: " << ContentStartColumn
2024 <<
", offset in line: " << TailOffset <<
"\n");
2029 BreakableToken::Split Split =
2030 Token->getSplit(NextLineIndex, TailOffset, ColumnLimit,
2031 ContentStartColumn, CommentPragmasRegex);
2032 if (Split.first == StringRef::npos) {
2033 LLVM_DEBUG(llvm::dbgs() <<
" Did not find later break\n");
2039 unsigned ToSplitColumns = Token->getRangeLength(
2040 NextLineIndex, TailOffset, Split.first, ContentStartColumn);
2041 if (ContentStartColumn + ToSplitColumns > ColumnLimit) {
2042 LLVM_DEBUG(llvm::dbgs() <<
" Next split protrudes, need: " 2043 << (ContentStartColumn + ToSplitColumns)
2044 <<
", space: " << ColumnLimit);
2045 unsigned ExcessCharactersPenalty =
2046 (ContentStartColumn + ToSplitColumns - ColumnLimit) *
2048 if (NewBreakPenalty < ExcessCharactersPenalty) {
2055 LLVM_DEBUG(llvm::dbgs() <<
"not found.\n");
2063 ContentStartColumn =
2064 Token->getContentStartColumn(NextLineIndex,
false);
2065 RemainingTokenColumns = Token->getRemainingLength(
2066 NextLineIndex, TailOffset, ContentStartColumn);
2069 Token->adaptStartOfLine(NextLineIndex, Whitespaces);
2084 if (NewBreakBefore) {
2085 assert(Penalty >= NewBreakPenalty);
2086 Penalty -= NewBreakPenalty;
2089 Token->reflow(NextLineIndex, Whitespaces);
2094 BreakableToken::Split SplitAfterLastLine =
2095 Token->getSplitAfterLastLine(TailOffset);
2096 if (SplitAfterLastLine.first != StringRef::npos) {
2097 LLVM_DEBUG(llvm::dbgs() <<
"Replacing whitespace after last line.\n");
2099 Token->replaceWhitespaceAfterLastLine(TailOffset, SplitAfterLastLine,
2101 ContentStartColumn =
2102 Token->getContentStartColumn(Token->getLineCount() - 1,
true);
2103 RemainingTokenColumns = Token->getRemainingLength(
2104 Token->getLineCount() - 1,
2105 TailOffset + SplitAfterLastLine.first + SplitAfterLastLine.second,
2106 ContentStartColumn);
2109 State.
Column = ContentStartColumn + RemainingTokenColumns -
2112 if (BreakInserted) {
2116 if (Current.
isNot(TT_LineComment)) {
2117 for (
unsigned i = 0, e = State.
Stack.size(); i != e; ++i)
2118 State.
Stack[i].BreakBeforeParameter =
true;
2121 if (Current.
is(TT_BlockComment))
2124 State.
Stack.back().LastSpace = StartColumn;
2127 Token->updateNextToken(State);
2129 return {Penalty, Exceeded};
2137 bool ContinuationIndenter::nextIsMultilineString(
const LineState &State) {
2144 if (Current.
TokenText.startswith(
"R\""))
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.
Token - This structure provides full information about a lexed token.
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.
std::string toString(const til::SExpr *E)
__DEVICE__ int max(int __a, int __b)
__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.