ContinuationIndenter.cpp revision 341825
1259701Sdim//===--- ContinuationIndenter.cpp - Format C++ code -----------------------===// 2259701Sdim// 3259701Sdim// The LLVM Compiler Infrastructure 4259701Sdim// 5259701Sdim// This file is distributed under the University of Illinois Open Source 6259701Sdim// License. See LICENSE.TXT for details. 7259701Sdim// 8259701Sdim//===----------------------------------------------------------------------===// 9259701Sdim/// 10259701Sdim/// \file 11341825Sdim/// This file implements the continuation indenter. 12259701Sdim/// 13259701Sdim//===----------------------------------------------------------------------===// 14259701Sdim 15327952Sdim#include "ContinuationIndenter.h" 16259701Sdim#include "BreakableToken.h" 17327952Sdim#include "FormatInternal.h" 18259701Sdim#include "WhitespaceManager.h" 19259701Sdim#include "clang/Basic/OperatorPrecedence.h" 20259701Sdim#include "clang/Basic/SourceManager.h" 21259701Sdim#include "clang/Format/Format.h" 22259701Sdim#include "llvm/Support/Debug.h" 23259701Sdim 24321369Sdim#define DEBUG_TYPE "format-indenter" 25276479Sdim 26259701Sdimnamespace clang { 27259701Sdimnamespace format { 28259701Sdim 29341825Sdim// Returns true if a TT_SelectorName should be indented when wrapped, 30341825Sdim// false otherwise. 31341825Sdimstatic bool shouldIndentWrappedSelectorName(const FormatStyle &Style, 32341825Sdim LineType LineType) { 33341825Sdim return Style.IndentWrappedFunctionNames || LineType == LT_ObjCMethodDecl; 34341825Sdim} 35341825Sdim 36259701Sdim// Returns the length of everything up to the first possible line break after 37259701Sdim// the ), ], } or > matching \c Tok. 38341825Sdimstatic unsigned getLengthToMatchingParen(const FormatToken &Tok, 39341825Sdim const std::vector<ParenState> &Stack) { 40341825Sdim // Normally whether or not a break before T is possible is calculated and 41341825Sdim // stored in T.CanBreakBefore. Braces, array initializers and text proto 42341825Sdim // messages like `key: < ... >` are an exception: a break is possible 43341825Sdim // before a closing brace R if a break was inserted after the corresponding 44341825Sdim // opening brace. The information about whether or not a break is needed 45341825Sdim // before a closing brace R is stored in the ParenState field 46341825Sdim // S.BreakBeforeClosingBrace where S is the state that R closes. 47341825Sdim // 48341825Sdim // In order to decide whether there can be a break before encountered right 49341825Sdim // braces, this implementation iterates over the sequence of tokens and over 50341825Sdim // the paren stack in lockstep, keeping track of the stack level which visited 51341825Sdim // right braces correspond to in MatchingStackIndex. 52341825Sdim // 53341825Sdim // For example, consider: 54341825Sdim // L. <- line number 55341825Sdim // 1. { 56341825Sdim // 2. {1}, 57341825Sdim // 3. {2}, 58341825Sdim // 4. {{3}}} 59341825Sdim // ^ where we call this method with this token. 60341825Sdim // The paren stack at this point contains 3 brace levels: 61341825Sdim // 0. { at line 1, BreakBeforeClosingBrace: true 62341825Sdim // 1. first { at line 4, BreakBeforeClosingBrace: false 63341825Sdim // 2. second { at line 4, BreakBeforeClosingBrace: false, 64341825Sdim // where there might be fake parens levels in-between these levels. 65341825Sdim // The algorithm will start at the first } on line 4, which is the matching 66341825Sdim // brace of the initial left brace and at level 2 of the stack. Then, 67341825Sdim // examining BreakBeforeClosingBrace: false at level 2, it will continue to 68341825Sdim // the second } on line 4, and will traverse the stack downwards until it 69341825Sdim // finds the matching { on level 1. Then, examining BreakBeforeClosingBrace: 70341825Sdim // false at level 1, it will continue to the third } on line 4 and will 71341825Sdim // traverse the stack downwards until it finds the matching { on level 0. 72341825Sdim // Then, examining BreakBeforeClosingBrace: true at level 0, the algorithm 73341825Sdim // will stop and will use the second } on line 4 to determine the length to 74341825Sdim // return, as in this example the range will include the tokens: {3}} 75341825Sdim // 76341825Sdim // The algorithm will only traverse the stack if it encounters braces, array 77341825Sdim // initializer squares or text proto angle brackets. 78276479Sdim if (!Tok.MatchingParen) 79259701Sdim return 0; 80259701Sdim FormatToken *End = Tok.MatchingParen; 81341825Sdim // Maintains a stack level corresponding to the current End token. 82341825Sdim int MatchingStackIndex = Stack.size() - 1; 83341825Sdim // Traverses the stack downwards, looking for the level to which LBrace 84341825Sdim // corresponds. Returns either a pointer to the matching level or nullptr if 85341825Sdim // LParen is not found in the initial portion of the stack up to 86341825Sdim // MatchingStackIndex. 87341825Sdim auto FindParenState = [&](const FormatToken *LBrace) -> const ParenState * { 88341825Sdim while (MatchingStackIndex >= 0 && Stack[MatchingStackIndex].Tok != LBrace) 89341825Sdim --MatchingStackIndex; 90341825Sdim return MatchingStackIndex >= 0 ? &Stack[MatchingStackIndex] : nullptr; 91341825Sdim }; 92341825Sdim for (; End->Next; End = End->Next) { 93341825Sdim if (End->Next->CanBreakBefore) 94341825Sdim break; 95341825Sdim if (!End->Next->closesScope()) 96341825Sdim continue; 97341825Sdim if (End->Next->MatchingParen && 98341825Sdim End->Next->MatchingParen->isOneOf( 99341825Sdim tok::l_brace, TT_ArrayInitializerLSquare, tok::less)) { 100341825Sdim const ParenState *State = FindParenState(End->Next->MatchingParen); 101341825Sdim if (State && State->BreakBeforeClosingBrace) 102341825Sdim break; 103341825Sdim } 104259701Sdim } 105259701Sdim return End->TotalLength - Tok.TotalLength + 1; 106259701Sdim} 107259701Sdim 108296417Sdimstatic unsigned getLengthToNextOperator(const FormatToken &Tok) { 109296417Sdim if (!Tok.NextOperator) 110296417Sdim return 0; 111296417Sdim return Tok.NextOperator->TotalLength - Tok.TotalLength; 112296417Sdim} 113296417Sdim 114259701Sdim// Returns \c true if \c Tok is the "." or "->" of a call and starts the next 115259701Sdim// segment of a builder type call. 116259701Sdimstatic bool startsSegmentOfBuilderTypeCall(const FormatToken &Tok) { 117259701Sdim return Tok.isMemberAccess() && Tok.Previous && Tok.Previous->closesScope(); 118259701Sdim} 119259701Sdim 120259701Sdim// Returns \c true if \c Current starts a new parameter. 121259701Sdimstatic bool startsNextParameter(const FormatToken &Current, 122259701Sdim const FormatStyle &Style) { 123259701Sdim const FormatToken &Previous = *Current.Previous; 124280031Sdim if (Current.is(TT_CtorInitializerComma) && 125321369Sdim Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma) 126259701Sdim return true; 127321369Sdim if (Style.Language == FormatStyle::LK_Proto && Current.is(TT_SelectorName)) 128321369Sdim return true; 129259701Sdim return Previous.is(tok::comma) && !Current.isTrailingComment() && 130321369Sdim ((Previous.isNot(TT_CtorInitializerComma) || 131321369Sdim Style.BreakConstructorInitializers != 132321369Sdim FormatStyle::BCIS_BeforeComma) && 133321369Sdim (Previous.isNot(TT_InheritanceComma) || 134341825Sdim Style.BreakInheritanceList != FormatStyle::BILS_BeforeComma)); 135259701Sdim} 136259701Sdim 137321369Sdimstatic bool opensProtoMessageField(const FormatToken &LessTok, 138321369Sdim const FormatStyle &Style) { 139321369Sdim if (LessTok.isNot(tok::less)) 140321369Sdim return false; 141321369Sdim return Style.Language == FormatStyle::LK_TextProto || 142321369Sdim (Style.Language == FormatStyle::LK_Proto && 143321369Sdim (LessTok.NestingLevel > 0 || 144321369Sdim (LessTok.Previous && LessTok.Previous->is(tok::equal)))); 145321369Sdim} 146321369Sdim 147327952Sdim// Returns the delimiter of a raw string literal, or None if TokenText is not 148327952Sdim// the text of a raw string literal. The delimiter could be the empty string. 149327952Sdim// For example, the delimiter of R"deli(cont)deli" is deli. 150327952Sdimstatic llvm::Optional<StringRef> getRawStringDelimiter(StringRef TokenText) { 151327952Sdim if (TokenText.size() < 5 // The smallest raw string possible is 'R"()"'. 152327952Sdim || !TokenText.startswith("R\"") || !TokenText.endswith("\"")) 153327952Sdim return None; 154327952Sdim 155327952Sdim // A raw string starts with 'R"<delimiter>(' and delimiter is ascii and has 156327952Sdim // size at most 16 by the standard, so the first '(' must be among the first 157327952Sdim // 19 bytes. 158327952Sdim size_t LParenPos = TokenText.substr(0, 19).find_first_of('('); 159327952Sdim if (LParenPos == StringRef::npos) 160327952Sdim return None; 161327952Sdim StringRef Delimiter = TokenText.substr(2, LParenPos - 2); 162327952Sdim 163327952Sdim // Check that the string ends in ')Delimiter"'. 164327952Sdim size_t RParenPos = TokenText.size() - Delimiter.size() - 2; 165327952Sdim if (TokenText[RParenPos] != ')') 166327952Sdim return None; 167327952Sdim if (!TokenText.substr(RParenPos + 1).startswith(Delimiter)) 168327952Sdim return None; 169327952Sdim return Delimiter; 170327952Sdim} 171327952Sdim 172341825Sdim// Returns the canonical delimiter for \p Language, or the empty string if no 173341825Sdim// canonical delimiter is specified. 174341825Sdimstatic StringRef 175341825SdimgetCanonicalRawStringDelimiter(const FormatStyle &Style, 176341825Sdim FormatStyle::LanguageKind Language) { 177341825Sdim for (const auto &Format : Style.RawStringFormats) { 178341825Sdim if (Format.Language == Language) 179341825Sdim return StringRef(Format.CanonicalDelimiter); 180341825Sdim } 181341825Sdim return ""; 182341825Sdim} 183341825Sdim 184327952SdimRawStringFormatStyleManager::RawStringFormatStyleManager( 185327952Sdim const FormatStyle &CodeStyle) { 186327952Sdim for (const auto &RawStringFormat : CodeStyle.RawStringFormats) { 187341825Sdim llvm::Optional<FormatStyle> LanguageStyle = 188341825Sdim CodeStyle.GetLanguageStyle(RawStringFormat.Language); 189341825Sdim if (!LanguageStyle) { 190341825Sdim FormatStyle PredefinedStyle; 191341825Sdim if (!getPredefinedStyle(RawStringFormat.BasedOnStyle, 192341825Sdim RawStringFormat.Language, &PredefinedStyle)) { 193341825Sdim PredefinedStyle = getLLVMStyle(); 194341825Sdim PredefinedStyle.Language = RawStringFormat.Language; 195341825Sdim } 196341825Sdim LanguageStyle = PredefinedStyle; 197327952Sdim } 198341825Sdim LanguageStyle->ColumnLimit = CodeStyle.ColumnLimit; 199341825Sdim for (StringRef Delimiter : RawStringFormat.Delimiters) { 200341825Sdim DelimiterStyle.insert({Delimiter, *LanguageStyle}); 201341825Sdim } 202341825Sdim for (StringRef EnclosingFunction : RawStringFormat.EnclosingFunctions) { 203341825Sdim EnclosingFunctionStyle.insert({EnclosingFunction, *LanguageStyle}); 204341825Sdim } 205327952Sdim } 206327952Sdim} 207327952Sdim 208327952Sdimllvm::Optional<FormatStyle> 209341825SdimRawStringFormatStyleManager::getDelimiterStyle(StringRef Delimiter) const { 210327952Sdim auto It = DelimiterStyle.find(Delimiter); 211327952Sdim if (It == DelimiterStyle.end()) 212327952Sdim return None; 213327952Sdim return It->second; 214327952Sdim} 215327952Sdim 216341825Sdimllvm::Optional<FormatStyle> 217341825SdimRawStringFormatStyleManager::getEnclosingFunctionStyle( 218341825Sdim StringRef EnclosingFunction) const { 219341825Sdim auto It = EnclosingFunctionStyle.find(EnclosingFunction); 220341825Sdim if (It == EnclosingFunctionStyle.end()) 221341825Sdim return None; 222341825Sdim return It->second; 223341825Sdim} 224341825Sdim 225259701SdimContinuationIndenter::ContinuationIndenter(const FormatStyle &Style, 226280031Sdim const AdditionalKeywords &Keywords, 227309124Sdim const SourceManager &SourceMgr, 228259701Sdim WhitespaceManager &Whitespaces, 229259701Sdim encoding::Encoding Encoding, 230259701Sdim bool BinPackInconclusiveFunctions) 231280031Sdim : Style(Style), Keywords(Keywords), SourceMgr(SourceMgr), 232280031Sdim Whitespaces(Whitespaces), Encoding(Encoding), 233276479Sdim BinPackInconclusiveFunctions(BinPackInconclusiveFunctions), 234327952Sdim CommentPragmasRegex(Style.CommentPragmas), RawStringFormats(Style) {} 235259701Sdim 236259701SdimLineState ContinuationIndenter::getInitialState(unsigned FirstIndent, 237327952Sdim unsigned FirstStartColumn, 238259701Sdim const AnnotatedLine *Line, 239259701Sdim bool DryRun) { 240259701Sdim LineState State; 241259701Sdim State.FirstIndent = FirstIndent; 242327952Sdim if (FirstStartColumn && Line->First->NewlinesBefore == 0) 243327952Sdim State.Column = FirstStartColumn; 244327952Sdim else 245327952Sdim State.Column = FirstIndent; 246327952Sdim // With preprocessor directive indentation, the line starts on column 0 247327952Sdim // since it's indented after the hash, but FirstIndent is set to the 248327952Sdim // preprocessor indent. 249327952Sdim if (Style.IndentPPDirectives == FormatStyle::PPDIS_AfterHash && 250327952Sdim (Line->Type == LT_PreprocessorDirective || 251327952Sdim Line->Type == LT_ImportStatement)) 252327952Sdim State.Column = 0; 253259701Sdim State.Line = Line; 254259701Sdim State.NextToken = Line->First; 255341825Sdim State.Stack.push_back(ParenState(/*Tok=*/nullptr, FirstIndent, FirstIndent, 256259701Sdim /*AvoidBinPacking=*/false, 257259701Sdim /*NoLineBreak=*/false)); 258259701Sdim State.LineContainsContinuedForLoopSection = false; 259327952Sdim State.NoContinuation = false; 260259701Sdim State.StartOfStringLiteral = 0; 261276479Sdim State.StartOfLineLevel = 0; 262276479Sdim State.LowestLevelOnLine = 0; 263259701Sdim State.IgnoreStackForComparison = false; 264259701Sdim 265321369Sdim if (Style.Language == FormatStyle::LK_TextProto) { 266321369Sdim // We need this in order to deal with the bin packing of text fields at 267321369Sdim // global scope. 268321369Sdim State.Stack.back().AvoidBinPacking = true; 269321369Sdim State.Stack.back().BreakBeforeParameter = true; 270341825Sdim State.Stack.back().AlignColons = false; 271321369Sdim } 272321369Sdim 273259701Sdim // The first token has already been indented and thus consumed. 274259701Sdim moveStateToNextToken(State, DryRun, /*Newline=*/false); 275259701Sdim return State; 276259701Sdim} 277259701Sdim 278259701Sdimbool ContinuationIndenter::canBreak(const LineState &State) { 279259701Sdim const FormatToken &Current = *State.NextToken; 280259701Sdim const FormatToken &Previous = *Current.Previous; 281259701Sdim assert(&Previous == Current.Previous); 282327952Sdim if (!Current.CanBreakBefore && !(State.Stack.back().BreakBeforeClosingBrace && 283327952Sdim Current.closesBlockOrBlockTypeList(Style))) 284259701Sdim return false; 285259701Sdim // The opening "{" of a braced list has to be on the same line as the first 286259701Sdim // element if it is nested in another braced init list or function call. 287259701Sdim if (!Current.MustBreakBefore && Previous.is(tok::l_brace) && 288280031Sdim Previous.isNot(TT_DictLiteral) && Previous.BlockKind == BK_BracedInit && 289276479Sdim Previous.Previous && 290259701Sdim Previous.Previous->isOneOf(tok::l_brace, tok::l_paren, tok::comma)) 291259701Sdim return false; 292259701Sdim // This prevents breaks like: 293259701Sdim // ... 294259701Sdim // SomeParameter, OtherParameter).DoSomething( 295259701Sdim // ... 296259701Sdim // As they hide "DoSomething" and are generally bad for readability. 297276479Sdim if (Previous.opensScope() && Previous.isNot(tok::l_brace) && 298276479Sdim State.LowestLevelOnLine < State.StartOfLineLevel && 299276479Sdim State.LowestLevelOnLine < Current.NestingLevel) 300259701Sdim return false; 301259701Sdim if (Current.isMemberAccess() && State.Stack.back().ContainsUnwrappedBuilder) 302259701Sdim return false; 303276479Sdim 304276479Sdim // Don't create a 'hanging' indent if there are multiple blocks in a single 305276479Sdim // statement. 306280031Sdim if (Previous.is(tok::l_brace) && State.Stack.size() > 1 && 307280031Sdim State.Stack[State.Stack.size() - 2].NestedBlockInlined && 308276479Sdim State.Stack[State.Stack.size() - 2].HasMultipleNestedBlocks) 309276479Sdim return false; 310276479Sdim 311280031Sdim // Don't break after very short return types (e.g. "void") as that is often 312280031Sdim // unexpected. 313296417Sdim if (Current.is(TT_FunctionDeclarationName) && State.Column < 6) { 314296417Sdim if (Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None) 315296417Sdim return false; 316296417Sdim } 317280031Sdim 318321369Sdim // If binary operators are moved to the next line (including commas for some 319321369Sdim // styles of constructor initializers), that's always ok. 320321369Sdim if (!Current.isOneOf(TT_BinaryOperator, tok::comma) && 321321369Sdim State.Stack.back().NoLineBreakInOperand) 322321369Sdim return false; 323321369Sdim 324341825Sdim if (Previous.is(tok::l_square) && Previous.is(TT_ObjCMethodExpr)) 325341825Sdim return false; 326341825Sdim 327259701Sdim return !State.Stack.back().NoLineBreak; 328259701Sdim} 329259701Sdim 330259701Sdimbool ContinuationIndenter::mustBreak(const LineState &State) { 331259701Sdim const FormatToken &Current = *State.NextToken; 332259701Sdim const FormatToken &Previous = *Current.Previous; 333280031Sdim if (Current.MustBreakBefore || Current.is(TT_InlineASMColon)) 334259701Sdim return true; 335259701Sdim if (State.Stack.back().BreakBeforeClosingBrace && 336296417Sdim Current.closesBlockOrBlockTypeList(Style)) 337259701Sdim return true; 338259701Sdim if (Previous.is(tok::semi) && State.LineContainsContinuedForLoopSection) 339259701Sdim return true; 340341825Sdim if (Style.Language == FormatStyle::LK_ObjC && 341341825Sdim Current.ObjCSelectorNameParts > 1 && 342341825Sdim Current.startsSequence(TT_SelectorName, tok::colon, tok::caret)) { 343341825Sdim return true; 344341825Sdim } 345259701Sdim if ((startsNextParameter(Current, Style) || Previous.is(tok::semi) || 346296417Sdim (Previous.is(TT_TemplateCloser) && Current.is(TT_StartOfName) && 347321369Sdim Style.isCpp() && 348296417Sdim // FIXME: This is a temporary workaround for the case where clang-format 349296417Sdim // sets BreakBeforeParameter to avoid bin packing and this creates a 350296417Sdim // completely unnecessary line break after a template type that isn't 351296417Sdim // line-wrapped. 352296417Sdim (Previous.NestingLevel == 1 || Style.BinPackParameters)) || 353288943Sdim (Style.BreakBeforeTernaryOperators && Current.is(TT_ConditionalExpr) && 354288943Sdim Previous.isNot(tok::question)) || 355259701Sdim (!Style.BreakBeforeTernaryOperators && 356288943Sdim Previous.is(TT_ConditionalExpr))) && 357259701Sdim State.Stack.back().BreakBeforeParameter && !Current.isTrailingComment() && 358259701Sdim !Current.isOneOf(tok::r_paren, tok::r_brace)) 359259701Sdim return true; 360280031Sdim if (((Previous.is(TT_DictLiteral) && Previous.is(tok::l_brace)) || 361296417Sdim (Previous.is(TT_ArrayInitializerLSquare) && 362321369Sdim Previous.ParameterCount > 1) || 363321369Sdim opensProtoMessageField(Previous, Style)) && 364276479Sdim Style.ColumnLimit > 0 && 365341825Sdim getLengthToMatchingParen(Previous, State.Stack) + State.Column - 1 > 366288943Sdim getColumnLimit(State)) 367259701Sdim return true; 368321369Sdim 369321369Sdim const FormatToken &BreakConstructorInitializersToken = 370321369Sdim Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon 371321369Sdim ? Previous 372321369Sdim : Current; 373321369Sdim if (BreakConstructorInitializersToken.is(TT_CtorInitializerColon) && 374321369Sdim (State.Column + State.Line->Last->TotalLength - Previous.TotalLength > 375296417Sdim getColumnLimit(State) || 376296417Sdim State.Stack.back().BreakBeforeParameter) && 377321369Sdim (Style.AllowShortFunctionsOnASingleLine != FormatStyle::SFS_All || 378321369Sdim Style.BreakConstructorInitializers != FormatStyle::BCIS_BeforeColon || 379321369Sdim Style.ColumnLimit != 0)) 380276479Sdim return true; 381321369Sdim 382314564Sdim if (Current.is(TT_ObjCMethodExpr) && !Previous.is(TT_SelectorName) && 383314564Sdim State.Line->startsWith(TT_ObjCMethodSpecifier)) 384314564Sdim return true; 385341825Sdim if (Current.is(TT_SelectorName) && !Previous.is(tok::at) && 386341825Sdim State.Stack.back().ObjCSelectorNameFound && 387288943Sdim State.Stack.back().BreakBeforeParameter) 388288943Sdim return true; 389259701Sdim 390288943Sdim unsigned NewLineColumn = getNewLineColumn(State); 391296417Sdim if (Current.isMemberAccess() && Style.ColumnLimit != 0 && 392296417Sdim State.Column + getLengthToNextOperator(Current) > Style.ColumnLimit && 393296417Sdim (State.Column > NewLineColumn || 394296417Sdim Current.NestingLevel < State.StartOfLineLevel)) 395296417Sdim return true; 396296417Sdim 397321369Sdim if (startsSegmentOfBuilderTypeCall(Current) && 398321369Sdim (State.Stack.back().CallContinuation != 0 || 399321369Sdim State.Stack.back().BreakBeforeParameter) && 400321369Sdim // JavaScript is treated different here as there is a frequent pattern: 401321369Sdim // SomeFunction(function() { 402321369Sdim // ... 403321369Sdim // }.bind(...)); 404321369Sdim // FIXME: We should find a more generic solution to this problem. 405321369Sdim !(State.Column <= NewLineColumn && 406321369Sdim Style.Language == FormatStyle::LK_JavaScript)) 407321369Sdim return true; 408321369Sdim 409341825Sdim // If the template declaration spans multiple lines, force wrap before the 410341825Sdim // function/class declaration 411341825Sdim if (Previous.ClosesTemplateDeclaration && 412341825Sdim State.Stack.back().BreakBeforeParameter && Current.CanBreakBefore) 413341825Sdim return true; 414341825Sdim 415296417Sdim if (State.Column <= NewLineColumn) 416276479Sdim return false; 417288943Sdim 418288943Sdim if (Style.AlwaysBreakBeforeMultilineStrings && 419288943Sdim (NewLineColumn == State.FirstIndent + Style.ContinuationIndentWidth || 420288943Sdim Previous.is(tok::comma) || Current.NestingLevel < 2) && 421288943Sdim !Previous.isOneOf(tok::kw_return, tok::lessless, tok::at) && 422288943Sdim !Previous.isOneOf(TT_InlineASMColon, TT_ConditionalExpr) && 423288943Sdim nextIsMultilineString(State)) 424288943Sdim return true; 425288943Sdim 426288943Sdim // Using CanBreakBefore here and below takes care of the decision whether the 427288943Sdim // current style uses wrapping before or after operators for the given 428288943Sdim // operator. 429288943Sdim if (Previous.is(TT_BinaryOperator) && Current.CanBreakBefore) { 430259701Sdim // If we need to break somewhere inside the LHS of a binary expression, we 431259701Sdim // should also break after the operator. Otherwise, the formatting would 432259701Sdim // hide the operator precedence, e.g. in: 433259701Sdim // if (aaaaaaaaaaaaaa == 434259701Sdim // bbbbbbbbbbbbbb && c) {.. 435259701Sdim // For comparisons, we only apply this rule, if the LHS is a binary 436259701Sdim // expression itself as otherwise, the line breaks seem superfluous. 437259701Sdim // We need special cases for ">>" which we have split into two ">" while 438259701Sdim // lexing in order to make template parsing easier. 439259701Sdim bool IsComparison = (Previous.getPrecedence() == prec::Relational || 440327952Sdim Previous.getPrecedence() == prec::Equality || 441327952Sdim Previous.getPrecedence() == prec::Spaceship) && 442259701Sdim Previous.Previous && 443280031Sdim Previous.Previous->isNot(TT_BinaryOperator); // For >>. 444259701Sdim bool LHSIsBinaryExpr = 445259701Sdim Previous.Previous && Previous.Previous->EndsBinaryExpression; 446288943Sdim if ((!IsComparison || LHSIsBinaryExpr) && !Current.isTrailingComment() && 447259701Sdim Previous.getPrecedence() != prec::Assignment && 448259701Sdim State.Stack.back().BreakBeforeParameter) 449259701Sdim return true; 450288943Sdim } else if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore && 451288943Sdim State.Stack.back().BreakBeforeParameter) { 452288943Sdim return true; 453259701Sdim } 454259701Sdim 455259701Sdim // Same as above, but for the first "<<" operator. 456280031Sdim if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator) && 457276479Sdim State.Stack.back().BreakBeforeParameter && 458259701Sdim State.Stack.back().FirstLessLess == 0) 459259701Sdim return true; 460259701Sdim 461280031Sdim if (Current.NestingLevel == 0 && !Current.isTrailingComment()) { 462288943Sdim // Always break after "template <...>" and leading annotations. This is only 463288943Sdim // for cases where the entire line does not fit on a single line as a 464288943Sdim // different LineFormatter would be used otherwise. 465280031Sdim if (Previous.ClosesTemplateDeclaration) 466341825Sdim return Style.AlwaysBreakTemplateDeclarations != FormatStyle::BTDS_No; 467288943Sdim if (Previous.is(TT_FunctionAnnotationRParen)) 468288943Sdim return true; 469280031Sdim if (Previous.is(TT_LeadingJavaAnnotation) && Current.isNot(tok::l_paren) && 470280031Sdim Current.isNot(TT_LeadingJavaAnnotation)) 471280031Sdim return true; 472280031Sdim } 473259701Sdim 474276479Sdim // If the return type spans multiple lines, wrap before the function name. 475296417Sdim if ((Current.is(TT_FunctionDeclarationName) || 476296417Sdim (Current.is(tok::kw_operator) && !Previous.is(tok::coloncolon))) && 477309124Sdim !Previous.is(tok::kw_template) && State.Stack.back().BreakBeforeParameter) 478259701Sdim return true; 479276479Sdim 480276479Sdim // The following could be precomputed as they do not depend on the state. 481276479Sdim // However, as they should take effect only if the UnwrappedLine does not fit 482276479Sdim // into the ColumnLimit, they are checked here in the ContinuationIndenter. 483276479Sdim if (Style.ColumnLimit != 0 && Previous.BlockKind == BK_Block && 484276479Sdim Previous.is(tok::l_brace) && !Current.isOneOf(tok::r_brace, tok::comment)) 485276479Sdim return true; 486276479Sdim 487296417Sdim if (Current.is(tok::lessless) && 488296417Sdim ((Previous.is(tok::identifier) && Previous.TokenText == "endl") || 489296417Sdim (Previous.Tok.isLiteral() && (Previous.TokenText.endswith("\\n\"") || 490296417Sdim Previous.TokenText == "\'\\n\'")))) 491288943Sdim return true; 492288943Sdim 493327952Sdim if (Previous.is(TT_BlockComment) && Previous.IsMultiline) 494327952Sdim return true; 495327952Sdim 496327952Sdim if (State.NoContinuation) 497327952Sdim return true; 498327952Sdim 499259701Sdim return false; 500259701Sdim} 501259701Sdim 502259701Sdimunsigned ContinuationIndenter::addTokenToState(LineState &State, bool Newline, 503259701Sdim bool DryRun, 504259701Sdim unsigned ExtraSpaces) { 505259701Sdim const FormatToken &Current = *State.NextToken; 506259701Sdim 507276479Sdim assert(!State.Stack.empty()); 508327952Sdim State.NoContinuation = false; 509327952Sdim 510280031Sdim if ((Current.is(TT_ImplicitStringLiteral) && 511276479Sdim (Current.Previous->Tok.getIdentifierInfo() == nullptr || 512259701Sdim Current.Previous->Tok.getIdentifierInfo()->getPPKeywordID() == 513259701Sdim tok::pp_not_keyword))) { 514288943Sdim unsigned EndColumn = 515288943Sdim SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getEnd()); 516288943Sdim if (Current.LastNewlineOffset != 0) { 517288943Sdim // If there is a newline within this token, the final column will solely 518288943Sdim // determined by the current end column. 519288943Sdim State.Column = EndColumn; 520288943Sdim } else { 521288943Sdim unsigned StartColumn = 522288943Sdim SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getBegin()); 523288943Sdim assert(EndColumn >= StartColumn); 524288943Sdim State.Column += EndColumn - StartColumn; 525288943Sdim } 526276479Sdim moveStateToNextToken(State, DryRun, /*Newline=*/false); 527259701Sdim return 0; 528259701Sdim } 529259701Sdim 530259701Sdim unsigned Penalty = 0; 531259701Sdim if (Newline) 532259701Sdim Penalty = addTokenOnNewLine(State, DryRun); 533259701Sdim else 534259701Sdim addTokenOnCurrentLine(State, DryRun, ExtraSpaces); 535259701Sdim 536259701Sdim return moveStateToNextToken(State, DryRun, Newline) + Penalty; 537259701Sdim} 538259701Sdim 539259701Sdimvoid ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun, 540259701Sdim unsigned ExtraSpaces) { 541259701Sdim FormatToken &Current = *State.NextToken; 542259701Sdim const FormatToken &Previous = *State.NextToken->Previous; 543259701Sdim if (Current.is(tok::equal) && 544276479Sdim (State.Line->First->is(tok::kw_for) || Current.NestingLevel == 0) && 545259701Sdim State.Stack.back().VariablePos == 0) { 546259701Sdim State.Stack.back().VariablePos = State.Column; 547259701Sdim // Move over * and & if they are bound to the variable name. 548259701Sdim const FormatToken *Tok = &Previous; 549259701Sdim while (Tok && State.Stack.back().VariablePos >= Tok->ColumnWidth) { 550259701Sdim State.Stack.back().VariablePos -= Tok->ColumnWidth; 551259701Sdim if (Tok->SpacesRequiredBefore != 0) 552259701Sdim break; 553259701Sdim Tok = Tok->Previous; 554259701Sdim } 555259701Sdim if (Previous.PartOfMultiVariableDeclStmt) 556259701Sdim State.Stack.back().LastSpace = State.Stack.back().VariablePos; 557259701Sdim } 558259701Sdim 559259701Sdim unsigned Spaces = Current.SpacesRequiredBefore + ExtraSpaces; 560259701Sdim 561327952Sdim // Indent preprocessor directives after the hash if required. 562327952Sdim int PPColumnCorrection = 0; 563327952Sdim if (Style.IndentPPDirectives == FormatStyle::PPDIS_AfterHash && 564327952Sdim Previous.is(tok::hash) && State.FirstIndent > 0 && 565327952Sdim (State.Line->Type == LT_PreprocessorDirective || 566327952Sdim State.Line->Type == LT_ImportStatement)) { 567327952Sdim Spaces += State.FirstIndent; 568327952Sdim 569327952Sdim // For preprocessor indent with tabs, State.Column will be 1 because of the 570327952Sdim // hash. This causes second-level indents onward to have an extra space 571327952Sdim // after the tabs. We avoid this misalignment by subtracting 1 from the 572327952Sdim // column value passed to replaceWhitespace(). 573327952Sdim if (Style.UseTab != FormatStyle::UT_Never) 574327952Sdim PPColumnCorrection = -1; 575327952Sdim } 576327952Sdim 577259701Sdim if (!DryRun) 578321369Sdim Whitespaces.replaceWhitespace(Current, /*Newlines=*/0, Spaces, 579327952Sdim State.Column + Spaces + PPColumnCorrection); 580259701Sdim 581321369Sdim // If "BreakBeforeInheritanceComma" mode, don't break within the inheritance 582321369Sdim // declaration unless there is multiple inheritance. 583341825Sdim if (Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma && 584341825Sdim Current.is(TT_InheritanceColon)) 585321369Sdim State.Stack.back().NoLineBreak = true; 586341825Sdim if (Style.BreakInheritanceList == FormatStyle::BILS_AfterColon && 587341825Sdim Previous.is(TT_InheritanceColon)) 588341825Sdim State.Stack.back().NoLineBreak = true; 589321369Sdim 590280031Sdim if (Current.is(TT_SelectorName) && 591276479Sdim !State.Stack.back().ObjCSelectorNameFound) { 592296417Sdim unsigned MinIndent = 593296417Sdim std::max(State.FirstIndent + Style.ContinuationIndentWidth, 594296417Sdim State.Stack.back().Indent); 595296417Sdim unsigned FirstColonPos = State.Column + Spaces + Current.ColumnWidth; 596276479Sdim if (Current.LongestObjCSelectorName == 0) 597276479Sdim State.Stack.back().AlignColons = false; 598296417Sdim else if (MinIndent + Current.LongestObjCSelectorName > FirstColonPos) 599296417Sdim State.Stack.back().ColonPos = MinIndent + Current.LongestObjCSelectorName; 600259701Sdim else 601296417Sdim State.Stack.back().ColonPos = FirstColonPos; 602259701Sdim } 603259701Sdim 604296417Sdim // In "AlwaysBreak" mode, enforce wrapping directly after the parenthesis by 605296417Sdim // disallowing any further line breaks if there is no line break after the 606296417Sdim // opening parenthesis. Don't break if it doesn't conserve columns. 607296417Sdim if (Style.AlignAfterOpenBracket == FormatStyle::BAS_AlwaysBreak && 608309124Sdim Previous.isOneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) && 609309124Sdim State.Column > getNewLineColumn(State) && 610327952Sdim (!Previous.Previous || !Previous.Previous->isOneOf( 611327952Sdim tok::kw_for, tok::kw_while, tok::kw_switch)) && 612309124Sdim // Don't do this for simple (no expressions) one-argument function calls 613309124Sdim // as that feels like needlessly wasting whitespace, e.g.: 614309124Sdim // 615309124Sdim // caaaaaaaaaaaall( 616309124Sdim // caaaaaaaaaaaall( 617309124Sdim // caaaaaaaaaaaall( 618309124Sdim // caaaaaaaaaaaaaaaaaaaaaaall(aaaaaaaaaaaaaa, aaaaaaaaa)))); 619309124Sdim Current.FakeLParens.size() > 0 && 620309124Sdim Current.FakeLParens.back() > prec::Unknown) 621296417Sdim State.Stack.back().NoLineBreak = true; 622321369Sdim if (Previous.is(TT_TemplateString) && Previous.opensScope()) 623321369Sdim State.Stack.back().NoLineBreak = true; 624296417Sdim 625296417Sdim if (Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign && 626296417Sdim Previous.opensScope() && Previous.isNot(TT_ObjCMethodExpr) && 627280031Sdim (Current.isNot(TT_LineComment) || Previous.BlockKind == BK_BracedInit)) 628259701Sdim State.Stack.back().Indent = State.Column + Spaces; 629259701Sdim if (State.Stack.back().AvoidBinPacking && startsNextParameter(Current, Style)) 630259701Sdim State.Stack.back().NoLineBreak = true; 631288943Sdim if (startsSegmentOfBuilderTypeCall(Current) && 632288943Sdim State.Column > getNewLineColumn(State)) 633259701Sdim State.Stack.back().ContainsUnwrappedBuilder = true; 634259701Sdim 635288943Sdim if (Current.is(TT_LambdaArrow) && Style.Language == FormatStyle::LK_Java) 636288943Sdim State.Stack.back().NoLineBreak = true; 637280031Sdim if (Current.isMemberAccess() && Previous.is(tok::r_paren) && 638280031Sdim (Previous.MatchingParen && 639321369Sdim (Previous.TotalLength - Previous.MatchingParen->TotalLength > 10))) 640280031Sdim // If there is a function call with long parameters, break before trailing 641280031Sdim // calls. This prevents things like: 642280031Sdim // EXPECT_CALL(SomeLongParameter).Times( 643280031Sdim // 2); 644280031Sdim // We don't want to do this for short parameters as they can just be 645280031Sdim // indexes. 646280031Sdim State.Stack.back().NoLineBreak = true; 647321369Sdim 648321369Sdim // Don't allow the RHS of an operator to be split over multiple lines unless 649321369Sdim // there is a line-break right after the operator. 650321369Sdim // Exclude relational operators, as there, it is always more desirable to 651321369Sdim // have the LHS 'left' of the RHS. 652321369Sdim const FormatToken *P = Current.getPreviousNonComment(); 653321369Sdim if (!Current.is(tok::comment) && P && 654321369Sdim (P->isOneOf(TT_BinaryOperator, tok::comma) || 655321369Sdim (P->is(TT_ConditionalExpr) && P->is(tok::colon))) && 656321369Sdim !P->isOneOf(TT_OverloadedOperator, TT_CtorInitializerComma) && 657321369Sdim P->getPrecedence() != prec::Assignment && 658327952Sdim P->getPrecedence() != prec::Relational && 659327952Sdim P->getPrecedence() != prec::Spaceship) { 660321369Sdim bool BreakBeforeOperator = 661321369Sdim P->MustBreakBefore || P->is(tok::lessless) || 662321369Sdim (P->is(TT_BinaryOperator) && 663321369Sdim Style.BreakBeforeBinaryOperators != FormatStyle::BOS_None) || 664321369Sdim (P->is(TT_ConditionalExpr) && Style.BreakBeforeTernaryOperators); 665321369Sdim // Don't do this if there are only two operands. In these cases, there is 666321369Sdim // always a nice vertical separation between them and the extra line break 667321369Sdim // does not help. 668321369Sdim bool HasTwoOperands = 669321369Sdim P->OperatorIndex == 0 && !P->NextOperator && !P->is(TT_ConditionalExpr); 670321369Sdim if ((!BreakBeforeOperator && !(HasTwoOperands && Style.AlignOperands)) || 671321369Sdim (!State.Stack.back().LastOperatorWrapped && BreakBeforeOperator)) 672321369Sdim State.Stack.back().NoLineBreakInOperand = true; 673280031Sdim } 674280031Sdim 675259701Sdim State.Column += Spaces; 676276479Sdim if (Current.isNot(tok::comment) && Previous.is(tok::l_paren) && 677280031Sdim Previous.Previous && 678321369Sdim (Previous.Previous->isOneOf(tok::kw_if, tok::kw_for) || 679321369Sdim Previous.Previous->endsSequence(tok::kw_constexpr, tok::kw_if))) { 680259701Sdim // Treat the condition inside an if as if it was a second function 681259701Sdim // parameter, i.e. let nested calls have a continuation indent. 682259701Sdim State.Stack.back().LastSpace = State.Column; 683280031Sdim State.Stack.back().NestedBlockIndent = State.Column; 684280031Sdim } else if (!Current.isOneOf(tok::comment, tok::caret) && 685296417Sdim ((Previous.is(tok::comma) && 686296417Sdim !Previous.is(TT_OverloadedOperator)) || 687280031Sdim (Previous.is(tok::colon) && Previous.is(TT_ObjCMethodExpr)))) { 688276479Sdim State.Stack.back().LastSpace = State.Column; 689321369Sdim } else if (Previous.is(TT_CtorInitializerColon) && 690321369Sdim Style.BreakConstructorInitializers == 691321369Sdim FormatStyle::BCIS_AfterColon) { 692321369Sdim State.Stack.back().Indent = State.Column; 693321369Sdim State.Stack.back().LastSpace = State.Column; 694280031Sdim } else if ((Previous.isOneOf(TT_BinaryOperator, TT_ConditionalExpr, 695280031Sdim TT_CtorInitializerColon)) && 696280031Sdim ((Previous.getPrecedence() != prec::Assignment && 697280031Sdim (Previous.isNot(tok::lessless) || Previous.OperatorIndex != 0 || 698296417Sdim Previous.NextOperator)) || 699280031Sdim Current.StartsBinaryExpression)) { 700309124Sdim // Indent relative to the RHS of the expression unless this is a simple 701309124Sdim // assignment without binary expression on the RHS. Also indent relative to 702309124Sdim // unary operators and the colons of constructor initializers. 703259701Sdim State.Stack.back().LastSpace = State.Column; 704280031Sdim } else if (Previous.is(TT_InheritanceColon)) { 705259701Sdim State.Stack.back().Indent = State.Column; 706259701Sdim State.Stack.back().LastSpace = State.Column; 707259701Sdim } else if (Previous.opensScope()) { 708259701Sdim // If a function has a trailing call, indent all parameters from the 709259701Sdim // opening parenthesis. This avoids confusing indents like: 710259701Sdim // OuterFunction(InnerFunctionCall( // break 711259701Sdim // ParameterToInnerFunction)) // break 712259701Sdim // .SecondInnerFunctionCall(); 713259701Sdim bool HasTrailingCall = false; 714259701Sdim if (Previous.MatchingParen) { 715259701Sdim const FormatToken *Next = Previous.MatchingParen->getNextNonComment(); 716259701Sdim HasTrailingCall = Next && Next->isMemberAccess(); 717259701Sdim } 718288943Sdim if (HasTrailingCall && State.Stack.size() > 1 && 719259701Sdim State.Stack[State.Stack.size() - 2].CallContinuation == 0) 720259701Sdim State.Stack.back().LastSpace = State.Column; 721259701Sdim } 722259701Sdim} 723259701Sdim 724259701Sdimunsigned ContinuationIndenter::addTokenOnNewLine(LineState &State, 725259701Sdim bool DryRun) { 726259701Sdim FormatToken &Current = *State.NextToken; 727259701Sdim const FormatToken &Previous = *State.NextToken->Previous; 728276479Sdim 729259701Sdim // Extra penalty that needs to be added because of the way certain line 730259701Sdim // breaks are chosen. 731259701Sdim unsigned Penalty = 0; 732259701Sdim 733276479Sdim const FormatToken *PreviousNonComment = Current.getPreviousNonComment(); 734276479Sdim const FormatToken *NextNonComment = Previous.getNextNonComment(); 735276479Sdim if (!NextNonComment) 736276479Sdim NextNonComment = &Current; 737276479Sdim // The first line break on any NestingLevel causes an extra penalty in order 738259701Sdim // prefer similar line breaks. 739259701Sdim if (!State.Stack.back().ContainsLineBreak) 740259701Sdim Penalty += 15; 741259701Sdim State.Stack.back().ContainsLineBreak = true; 742259701Sdim 743259701Sdim Penalty += State.NextToken->SplitPenalty; 744259701Sdim 745259701Sdim // Breaking before the first "<<" is generally not desirable if the LHS is 746314564Sdim // short. Also always add the penalty if the LHS is split over multiple lines 747276479Sdim // to avoid unnecessary line breaks that just work around this penalty. 748276479Sdim if (NextNonComment->is(tok::lessless) && 749276479Sdim State.Stack.back().FirstLessLess == 0 && 750276479Sdim (State.Column <= Style.ColumnLimit / 3 || 751276479Sdim State.Stack.back().BreakBeforeParameter)) 752259701Sdim Penalty += Style.PenaltyBreakFirstLessLess; 753259701Sdim 754276479Sdim State.Column = getNewLineColumn(State); 755288943Sdim 756288943Sdim // Indent nested blocks relative to this column, unless in a very specific 757288943Sdim // JavaScript special case where: 758288943Sdim // 759288943Sdim // var loooooong_name = 760288943Sdim // function() { 761288943Sdim // // code 762288943Sdim // } 763288943Sdim // 764309124Sdim // is common and should be formatted like a free-standing function. The same 765309124Sdim // goes for wrapping before the lambda return type arrow. 766309124Sdim if (!Current.is(TT_LambdaArrow) && 767309124Sdim (Style.Language != FormatStyle::LK_JavaScript || 768309124Sdim Current.NestingLevel != 0 || !PreviousNonComment || 769309124Sdim !PreviousNonComment->is(tok::equal) || 770309124Sdim !Current.isOneOf(Keywords.kw_async, Keywords.kw_function))) 771288943Sdim State.Stack.back().NestedBlockIndent = State.Column; 772288943Sdim 773276479Sdim if (NextNonComment->isMemberAccess()) { 774276479Sdim if (State.Stack.back().CallContinuation == 0) 775259701Sdim State.Stack.back().CallContinuation = State.Column; 776280031Sdim } else if (NextNonComment->is(TT_SelectorName)) { 777276479Sdim if (!State.Stack.back().ObjCSelectorNameFound) { 778276479Sdim if (NextNonComment->LongestObjCSelectorName == 0) { 779276479Sdim State.Stack.back().AlignColons = false; 780276479Sdim } else { 781276479Sdim State.Stack.back().ColonPos = 782341825Sdim (shouldIndentWrappedSelectorName(Style, State.Line->Type) 783288943Sdim ? std::max(State.Stack.back().Indent, 784288943Sdim State.FirstIndent + Style.ContinuationIndentWidth) 785288943Sdim : State.Stack.back().Indent) + 786341825Sdim std::max(NextNonComment->LongestObjCSelectorName, 787341825Sdim NextNonComment->ColumnWidth); 788276479Sdim } 789276479Sdim } else if (State.Stack.back().AlignColons && 790276479Sdim State.Stack.back().ColonPos <= NextNonComment->ColumnWidth) { 791276479Sdim State.Stack.back().ColonPos = State.Column + NextNonComment->ColumnWidth; 792259701Sdim } 793276479Sdim } else if (PreviousNonComment && PreviousNonComment->is(tok::colon) && 794280031Sdim PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) { 795276479Sdim // FIXME: This is hacky, find a better way. The problem is that in an ObjC 796276479Sdim // method expression, the block should be aligned to the line starting it, 797276479Sdim // e.g.: 798276479Sdim // [aaaaaaaaaaaaaaa aaaaaaaaa: \\ break for some reason 799276479Sdim // ^(int *i) { 800276479Sdim // // ... 801276479Sdim // }]; 802276479Sdim // Thus, we set LastSpace of the next higher NestingLevel, to which we move 803276479Sdim // when we consume all of the "}"'s FakeRParens at the "{". 804276479Sdim if (State.Stack.size() > 1) 805276479Sdim State.Stack[State.Stack.size() - 2].LastSpace = 806276479Sdim std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) + 807276479Sdim Style.ContinuationIndentWidth; 808259701Sdim } 809259701Sdim 810314564Sdim if ((PreviousNonComment && 811314564Sdim PreviousNonComment->isOneOf(tok::comma, tok::semi) && 812259701Sdim !State.Stack.back().AvoidBinPacking) || 813280031Sdim Previous.is(TT_BinaryOperator)) 814259701Sdim State.Stack.back().BreakBeforeParameter = false; 815341825Sdim if (PreviousNonComment && 816341825Sdim PreviousNonComment->isOneOf(TT_TemplateCloser, TT_JavaAnnotation) && 817280031Sdim Current.NestingLevel == 0) 818259701Sdim State.Stack.back().BreakBeforeParameter = false; 819276479Sdim if (NextNonComment->is(tok::question) || 820259701Sdim (PreviousNonComment && PreviousNonComment->is(tok::question))) 821259701Sdim State.Stack.back().BreakBeforeParameter = true; 822288943Sdim if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore) 823288943Sdim State.Stack.back().BreakBeforeParameter = false; 824259701Sdim 825259701Sdim if (!DryRun) { 826327952Sdim unsigned MaxEmptyLinesToKeep = Style.MaxEmptyLinesToKeep + 1; 827327952Sdim if (Current.is(tok::r_brace) && Current.MatchingParen && 828327952Sdim // Only strip trailing empty lines for l_braces that have children, i.e. 829327952Sdim // for function expressions (lambdas, arrows, etc). 830327952Sdim !Current.MatchingParen->Children.empty()) { 831327952Sdim // lambdas and arrow functions are expressions, thus their r_brace is not 832327952Sdim // on its own line, and thus not covered by UnwrappedLineFormatter's logic 833327952Sdim // about removing empty lines on closing blocks. Special case them here. 834327952Sdim MaxEmptyLinesToKeep = 1; 835327952Sdim } 836276479Sdim unsigned Newlines = std::max( 837327952Sdim 1u, std::min(Current.NewlinesBefore, MaxEmptyLinesToKeep)); 838321369Sdim bool ContinuePPDirective = 839321369Sdim State.Line->InPPDirective && State.Line->Type != LT_ImportStatement; 840321369Sdim Whitespaces.replaceWhitespace(Current, Newlines, State.Column, State.Column, 841321369Sdim ContinuePPDirective); 842259701Sdim } 843259701Sdim 844259701Sdim if (!Current.isTrailingComment()) 845259701Sdim State.Stack.back().LastSpace = State.Column; 846309124Sdim if (Current.is(tok::lessless)) 847309124Sdim // If we are breaking before a "<<", we always want to indent relative to 848309124Sdim // RHS. This is necessary only for "<<", as we special-case it and don't 849309124Sdim // always indent relative to the RHS. 850309124Sdim State.Stack.back().LastSpace += 3; // 3 -> width of "<< ". 851309124Sdim 852276479Sdim State.StartOfLineLevel = Current.NestingLevel; 853276479Sdim State.LowestLevelOnLine = Current.NestingLevel; 854259701Sdim 855259701Sdim // Any break on this level means that the parent level has been broken 856259701Sdim // and we need to avoid bin packing there. 857280031Sdim bool NestedBlockSpecialCase = 858321369Sdim !Style.isCpp() && Current.is(tok::r_brace) && State.Stack.size() > 1 && 859280031Sdim State.Stack[State.Stack.size() - 2].NestedBlockInlined; 860288943Sdim if (!NestedBlockSpecialCase) 861288943Sdim for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i) 862276479Sdim State.Stack[i].BreakBeforeParameter = true; 863276479Sdim 864259701Sdim if (PreviousNonComment && 865321369Sdim !PreviousNonComment->isOneOf(tok::comma, tok::colon, tok::semi) && 866280031Sdim (PreviousNonComment->isNot(TT_TemplateCloser) || 867280031Sdim Current.NestingLevel != 0) && 868288943Sdim !PreviousNonComment->isOneOf( 869288943Sdim TT_BinaryOperator, TT_FunctionAnnotationRParen, TT_JavaAnnotation, 870288943Sdim TT_LeadingJavaAnnotation) && 871280031Sdim Current.isNot(TT_BinaryOperator) && !PreviousNonComment->opensScope()) 872259701Sdim State.Stack.back().BreakBeforeParameter = true; 873259701Sdim 874259701Sdim // If we break after { or the [ of an array initializer, we should also break 875259701Sdim // before the corresponding } or ]. 876276479Sdim if (PreviousNonComment && 877321369Sdim (PreviousNonComment->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) || 878327952Sdim opensProtoMessageField(*PreviousNonComment, Style))) 879259701Sdim State.Stack.back().BreakBeforeClosingBrace = true; 880259701Sdim 881259701Sdim if (State.Stack.back().AvoidBinPacking) { 882259701Sdim // If we are breaking after '(', '{', '<', this is not bin packing 883276479Sdim // unless AllowAllParametersOfDeclarationOnNextLine is false or this is a 884276479Sdim // dict/object literal. 885280031Sdim if (!Previous.isOneOf(tok::l_paren, tok::l_brace, TT_BinaryOperator) || 886259701Sdim (!Style.AllowAllParametersOfDeclarationOnNextLine && 887276479Sdim State.Line->MustBeDeclaration) || 888280031Sdim Previous.is(TT_DictLiteral)) 889259701Sdim State.Stack.back().BreakBeforeParameter = true; 890259701Sdim } 891259701Sdim 892259701Sdim return Penalty; 893259701Sdim} 894259701Sdim 895276479Sdimunsigned ContinuationIndenter::getNewLineColumn(const LineState &State) { 896276479Sdim if (!State.NextToken || !State.NextToken->Previous) 897276479Sdim return 0; 898276479Sdim FormatToken &Current = *State.NextToken; 899280031Sdim const FormatToken &Previous = *Current.Previous; 900276479Sdim // If we are continuing an expression, we want to use the continuation indent. 901276479Sdim unsigned ContinuationIndent = 902276479Sdim std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) + 903276479Sdim Style.ContinuationIndentWidth; 904276479Sdim const FormatToken *PreviousNonComment = Current.getPreviousNonComment(); 905276479Sdim const FormatToken *NextNonComment = Previous.getNextNonComment(); 906276479Sdim if (!NextNonComment) 907276479Sdim NextNonComment = &Current; 908280031Sdim 909280031Sdim // Java specific bits. 910280031Sdim if (Style.Language == FormatStyle::LK_Java && 911280031Sdim Current.isOneOf(Keywords.kw_implements, Keywords.kw_extends)) 912280031Sdim return std::max(State.Stack.back().LastSpace, 913280031Sdim State.Stack.back().Indent + Style.ContinuationIndentWidth); 914280031Sdim 915276479Sdim if (NextNonComment->is(tok::l_brace) && NextNonComment->BlockKind == BK_Block) 916276479Sdim return Current.NestingLevel == 0 ? State.FirstIndent 917276479Sdim : State.Stack.back().Indent; 918321369Sdim if ((Current.isOneOf(tok::r_brace, tok::r_square) || 919321369Sdim (Current.is(tok::greater) && 920321369Sdim (Style.Language == FormatStyle::LK_Proto || 921321369Sdim Style.Language == FormatStyle::LK_TextProto))) && 922321369Sdim State.Stack.size() > 1) { 923296417Sdim if (Current.closesBlockOrBlockTypeList(Style)) 924280031Sdim return State.Stack[State.Stack.size() - 2].NestedBlockIndent; 925280031Sdim if (Current.MatchingParen && 926280031Sdim Current.MatchingParen->BlockKind == BK_BracedInit) 927276479Sdim return State.Stack[State.Stack.size() - 2].LastSpace; 928280031Sdim return State.FirstIndent; 929276479Sdim } 930321369Sdim // Indent a closing parenthesis at the previous level if followed by a semi or 931321369Sdim // opening brace. This allows indentations such as: 932321369Sdim // foo( 933321369Sdim // a, 934321369Sdim // ); 935321369Sdim // function foo( 936321369Sdim // a, 937321369Sdim // ) { 938321369Sdim // code(); // 939321369Sdim // } 940321369Sdim if (Current.is(tok::r_paren) && State.Stack.size() > 1 && 941321369Sdim (!Current.Next || Current.Next->isOneOf(tok::semi, tok::l_brace))) 942321369Sdim return State.Stack[State.Stack.size() - 2].LastSpace; 943321369Sdim if (NextNonComment->is(TT_TemplateString) && NextNonComment->closesScope()) 944321369Sdim return State.Stack[State.Stack.size() - 2].LastSpace; 945276479Sdim if (Current.is(tok::identifier) && Current.Next && 946327952Sdim (Current.Next->is(TT_DictLiteral) || 947327952Sdim ((Style.Language == FormatStyle::LK_Proto || 948327952Sdim Style.Language == FormatStyle::LK_TextProto) && 949341825Sdim Current.Next->isOneOf(tok::less, tok::l_brace)))) 950276479Sdim return State.Stack.back().Indent; 951288943Sdim if (NextNonComment->is(TT_ObjCStringLiteral) && 952288943Sdim State.StartOfStringLiteral != 0) 953288943Sdim return State.StartOfStringLiteral - 1; 954321369Sdim if (NextNonComment->isStringLiteral() && State.StartOfStringLiteral != 0) 955321369Sdim return State.StartOfStringLiteral; 956276479Sdim if (NextNonComment->is(tok::lessless) && 957276479Sdim State.Stack.back().FirstLessLess != 0) 958276479Sdim return State.Stack.back().FirstLessLess; 959276479Sdim if (NextNonComment->isMemberAccess()) { 960280031Sdim if (State.Stack.back().CallContinuation == 0) 961276479Sdim return ContinuationIndent; 962280031Sdim return State.Stack.back().CallContinuation; 963276479Sdim } 964276479Sdim if (State.Stack.back().QuestionColumn != 0 && 965276479Sdim ((NextNonComment->is(tok::colon) && 966280031Sdim NextNonComment->is(TT_ConditionalExpr)) || 967280031Sdim Previous.is(TT_ConditionalExpr))) 968276479Sdim return State.Stack.back().QuestionColumn; 969276479Sdim if (Previous.is(tok::comma) && State.Stack.back().VariablePos != 0) 970276479Sdim return State.Stack.back().VariablePos; 971280031Sdim if ((PreviousNonComment && 972280031Sdim (PreviousNonComment->ClosesTemplateDeclaration || 973288943Sdim PreviousNonComment->isOneOf( 974341825Sdim TT_AttributeParen, TT_AttributeSquare, TT_FunctionAnnotationRParen, 975341825Sdim TT_JavaAnnotation, TT_LeadingJavaAnnotation))) || 976276479Sdim (!Style.IndentWrappedFunctionNames && 977280031Sdim NextNonComment->isOneOf(tok::kw_operator, TT_FunctionDeclarationName))) 978276479Sdim return std::max(State.Stack.back().LastSpace, State.Stack.back().Indent); 979280031Sdim if (NextNonComment->is(TT_SelectorName)) { 980276479Sdim if (!State.Stack.back().ObjCSelectorNameFound) { 981341825Sdim unsigned MinIndent = State.Stack.back().Indent; 982341825Sdim if (shouldIndentWrappedSelectorName(Style, State.Line->Type)) 983341825Sdim MinIndent = std::max(MinIndent, 984341825Sdim State.FirstIndent + Style.ContinuationIndentWidth); 985341825Sdim // If LongestObjCSelectorName is 0, we are indenting the first 986341825Sdim // part of an ObjC selector (or a selector component which is 987341825Sdim // not colon-aligned due to block formatting). 988341825Sdim // 989341825Sdim // Otherwise, we are indenting a subsequent part of an ObjC 990341825Sdim // selector which should be colon-aligned to the longest 991341825Sdim // component of the ObjC selector. 992341825Sdim // 993341825Sdim // In either case, we want to respect Style.IndentWrappedFunctionNames. 994341825Sdim return MinIndent + 995341825Sdim std::max(NextNonComment->LongestObjCSelectorName, 996341825Sdim NextNonComment->ColumnWidth) - 997280031Sdim NextNonComment->ColumnWidth; 998280031Sdim } 999280031Sdim if (!State.Stack.back().AlignColons) 1000276479Sdim return State.Stack.back().Indent; 1001280031Sdim if (State.Stack.back().ColonPos > NextNonComment->ColumnWidth) 1002276479Sdim return State.Stack.back().ColonPos - NextNonComment->ColumnWidth; 1003280031Sdim return State.Stack.back().Indent; 1004276479Sdim } 1005314564Sdim if (NextNonComment->is(tok::colon) && NextNonComment->is(TT_ObjCMethodExpr)) 1006314564Sdim return State.Stack.back().ColonPos; 1007280031Sdim if (NextNonComment->is(TT_ArraySubscriptLSquare)) { 1008276479Sdim if (State.Stack.back().StartOfArraySubscripts != 0) 1009276479Sdim return State.Stack.back().StartOfArraySubscripts; 1010280031Sdim return ContinuationIndent; 1011276479Sdim } 1012288943Sdim 1013288943Sdim // This ensure that we correctly format ObjC methods calls without inputs, 1014288943Sdim // i.e. where the last element isn't selector like: [callee method]; 1015288943Sdim if (NextNonComment->is(tok::identifier) && NextNonComment->FakeRParens == 0 && 1016288943Sdim NextNonComment->Next && NextNonComment->Next->is(TT_ObjCMethodExpr)) 1017288943Sdim return State.Stack.back().Indent; 1018288943Sdim 1019288943Sdim if (NextNonComment->isOneOf(TT_StartOfName, TT_PointerOrReference) || 1020288943Sdim Previous.isOneOf(tok::coloncolon, tok::equal, TT_JsTypeColon)) 1021276479Sdim return ContinuationIndent; 1022276479Sdim if (PreviousNonComment && PreviousNonComment->is(tok::colon) && 1023280031Sdim PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) 1024276479Sdim return ContinuationIndent; 1025280031Sdim if (NextNonComment->is(TT_CtorInitializerComma)) 1026276479Sdim return State.Stack.back().Indent; 1027321369Sdim if (PreviousNonComment && PreviousNonComment->is(TT_CtorInitializerColon) && 1028321369Sdim Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon) 1029321369Sdim return State.Stack.back().Indent; 1030341825Sdim if (PreviousNonComment && PreviousNonComment->is(TT_InheritanceColon) && 1031341825Sdim Style.BreakInheritanceList == FormatStyle::BILS_AfterColon) 1032341825Sdim return State.Stack.back().Indent; 1033321369Sdim if (NextNonComment->isOneOf(TT_CtorInitializerColon, TT_InheritanceColon, 1034321369Sdim TT_InheritanceComma)) 1035321369Sdim return State.FirstIndent + Style.ConstructorInitializerIndentWidth; 1036280031Sdim if (Previous.is(tok::r_paren) && !Current.isBinaryOperator() && 1037280031Sdim !Current.isOneOf(tok::colon, tok::comment)) 1038280031Sdim return ContinuationIndent; 1039341825Sdim if (Current.is(TT_ProtoExtensionLSquare)) 1040341825Sdim return State.Stack.back().Indent; 1041276479Sdim if (State.Stack.back().Indent == State.FirstIndent && PreviousNonComment && 1042276479Sdim PreviousNonComment->isNot(tok::r_brace)) 1043276479Sdim // Ensure that we fall back to the continuation indent width instead of 1044276479Sdim // just flushing continuations left. 1045276479Sdim return State.Stack.back().Indent + Style.ContinuationIndentWidth; 1046276479Sdim return State.Stack.back().Indent; 1047276479Sdim} 1048276479Sdim 1049259701Sdimunsigned ContinuationIndenter::moveStateToNextToken(LineState &State, 1050259701Sdim bool DryRun, bool Newline) { 1051276479Sdim assert(State.Stack.size()); 1052259701Sdim const FormatToken &Current = *State.NextToken; 1053259701Sdim 1054321369Sdim if (Current.isOneOf(tok::comma, TT_BinaryOperator)) 1055321369Sdim State.Stack.back().NoLineBreakInOperand = false; 1056280031Sdim if (Current.is(TT_InheritanceColon)) 1057259701Sdim State.Stack.back().AvoidBinPacking = true; 1058280031Sdim if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) { 1059276479Sdim if (State.Stack.back().FirstLessLess == 0) 1060276479Sdim State.Stack.back().FirstLessLess = State.Column; 1061276479Sdim else 1062276479Sdim State.Stack.back().LastOperatorWrapped = Newline; 1063276479Sdim } 1064321369Sdim if (Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless)) 1065276479Sdim State.Stack.back().LastOperatorWrapped = Newline; 1066321369Sdim if (Current.is(TT_ConditionalExpr) && Current.Previous && 1067321369Sdim !Current.Previous->is(TT_ConditionalExpr)) 1068321369Sdim State.Stack.back().LastOperatorWrapped = Newline; 1069280031Sdim if (Current.is(TT_ArraySubscriptLSquare) && 1070259701Sdim State.Stack.back().StartOfArraySubscripts == 0) 1071259701Sdim State.Stack.back().StartOfArraySubscripts = State.Column; 1072309124Sdim if (Style.BreakBeforeTernaryOperators && Current.is(tok::question)) 1073259701Sdim State.Stack.back().QuestionColumn = State.Column; 1074309124Sdim if (!Style.BreakBeforeTernaryOperators && Current.isNot(tok::colon)) { 1075309124Sdim const FormatToken *Previous = Current.Previous; 1076309124Sdim while (Previous && Previous->isTrailingComment()) 1077309124Sdim Previous = Previous->Previous; 1078309124Sdim if (Previous && Previous->is(tok::question)) 1079309124Sdim State.Stack.back().QuestionColumn = State.Column; 1080309124Sdim } 1081321369Sdim if (!Current.opensScope() && !Current.closesScope() && 1082321369Sdim !Current.is(TT_PointerOrReference)) 1083259701Sdim State.LowestLevelOnLine = 1084276479Sdim std::min(State.LowestLevelOnLine, Current.NestingLevel); 1085259701Sdim if (Current.isMemberAccess()) 1086259701Sdim State.Stack.back().StartOfFunctionCall = 1087296417Sdim !Current.NextOperator ? 0 : State.Column; 1088341825Sdim if (Current.is(TT_SelectorName)) 1089276479Sdim State.Stack.back().ObjCSelectorNameFound = true; 1090321369Sdim if (Current.is(TT_CtorInitializerColon) && 1091321369Sdim Style.BreakConstructorInitializers != FormatStyle::BCIS_AfterColon) { 1092259701Sdim // Indent 2 from the column, so: 1093259701Sdim // SomeClass::SomeClass() 1094259701Sdim // : First(...), ... 1095259701Sdim // Next(...) 1096259701Sdim // ^ line up here. 1097259701Sdim State.Stack.back().Indent = 1098327952Sdim State.Column + 1099327952Sdim (Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma 1100327952Sdim ? 0 1101327952Sdim : 2); 1102280031Sdim State.Stack.back().NestedBlockIndent = State.Stack.back().Indent; 1103259701Sdim if (Style.ConstructorInitializerAllOnOneLineOrOnePerLine) 1104259701Sdim State.Stack.back().AvoidBinPacking = true; 1105259701Sdim State.Stack.back().BreakBeforeParameter = false; 1106259701Sdim } 1107321369Sdim if (Current.is(TT_CtorInitializerColon) && 1108321369Sdim Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon) { 1109321369Sdim State.Stack.back().Indent = 1110321369Sdim State.FirstIndent + Style.ConstructorInitializerIndentWidth; 1111321369Sdim State.Stack.back().NestedBlockIndent = State.Stack.back().Indent; 1112321369Sdim if (Style.ConstructorInitializerAllOnOneLineOrOnePerLine) 1113327952Sdim State.Stack.back().AvoidBinPacking = true; 1114321369Sdim } 1115321369Sdim if (Current.is(TT_InheritanceColon)) 1116321369Sdim State.Stack.back().Indent = 1117341825Sdim State.FirstIndent + Style.ConstructorInitializerIndentWidth; 1118288943Sdim if (Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline) 1119288943Sdim State.Stack.back().NestedBlockIndent = 1120288943Sdim State.Column + Current.ColumnWidth + 1; 1121321369Sdim if (Current.isOneOf(TT_LambdaLSquare, TT_LambdaArrow)) 1122321369Sdim State.Stack.back().LastSpace = State.Column; 1123259701Sdim 1124259701Sdim // Insert scopes created by fake parenthesis. 1125259701Sdim const FormatToken *Previous = Current.getPreviousNonComment(); 1126276479Sdim 1127276479Sdim // Add special behavior to support a format commonly used for JavaScript 1128276479Sdim // closures: 1129276479Sdim // SomeFunction(function() { 1130276479Sdim // foo(); 1131276479Sdim // bar(); 1132276479Sdim // }, a, b, c); 1133288943Sdim if (Current.isNot(tok::comment) && Previous && 1134288943Sdim Previous->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) && 1135296417Sdim !Previous->is(TT_DictLiteral) && State.Stack.size() > 1) { 1136288943Sdim if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline) 1137288943Sdim for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i) 1138280031Sdim State.Stack[i].NoLineBreak = true; 1139280031Sdim State.Stack[State.Stack.size() - 2].NestedBlockInlined = false; 1140276479Sdim } 1141327952Sdim if (Previous && 1142327952Sdim (Previous->isOneOf(tok::l_paren, tok::comma, tok::colon) || 1143327952Sdim Previous->isOneOf(TT_BinaryOperator, TT_ConditionalExpr)) && 1144280031Sdim !Previous->isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)) { 1145280031Sdim State.Stack.back().NestedBlockInlined = 1146280031Sdim !Newline && 1147280031Sdim (Previous->isNot(tok::l_paren) || Previous->ParameterCount > 1); 1148280031Sdim } 1149276479Sdim 1150276479Sdim moveStatePastFakeLParens(State, Newline); 1151321369Sdim moveStatePastScopeCloser(State); 1152327952Sdim bool AllowBreak = !State.Stack.back().NoLineBreak && 1153327952Sdim !State.Stack.back().NoLineBreakInOperand; 1154276479Sdim moveStatePastScopeOpener(State, Newline); 1155276479Sdim moveStatePastFakeRParens(State); 1156276479Sdim 1157288943Sdim if (Current.is(TT_ObjCStringLiteral) && State.StartOfStringLiteral == 0) 1158288943Sdim State.StartOfStringLiteral = State.Column + 1; 1159321369Sdim else if (Current.isStringLiteral() && State.StartOfStringLiteral == 0) 1160321369Sdim State.StartOfStringLiteral = State.Column; 1161288943Sdim else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) && 1162288943Sdim !Current.isStringLiteral()) 1163276479Sdim State.StartOfStringLiteral = 0; 1164276479Sdim 1165276479Sdim State.Column += Current.ColumnWidth; 1166276479Sdim State.NextToken = State.NextToken->Next; 1167276479Sdim 1168327952Sdim unsigned Penalty = 1169327952Sdim handleEndOfLine(Current, State, DryRun, AllowBreak); 1170327952Sdim 1171276479Sdim if (Current.Role) 1172276479Sdim Current.Role->formatFromToken(State, this, DryRun); 1173276479Sdim // If the previous has a special role, let it consume tokens as appropriate. 1174276479Sdim // It is necessary to start at the previous token for the only implemented 1175276479Sdim // role (comma separated list). That way, the decision whether or not to break 1176276479Sdim // after the "{" is already done and both options are tried and evaluated. 1177276479Sdim // FIXME: This is ugly, find a better way. 1178276479Sdim if (Previous && Previous->Role) 1179276479Sdim Penalty += Previous->Role->formatAfterToken(State, this, DryRun); 1180276479Sdim 1181276479Sdim return Penalty; 1182276479Sdim} 1183276479Sdim 1184276479Sdimvoid ContinuationIndenter::moveStatePastFakeLParens(LineState &State, 1185276479Sdim bool Newline) { 1186276479Sdim const FormatToken &Current = *State.NextToken; 1187276479Sdim const FormatToken *Previous = Current.getPreviousNonComment(); 1188276479Sdim 1189259701Sdim // Don't add extra indentation for the first fake parenthesis after 1190276479Sdim // 'return', assignments or opening <({[. The indentation for these cases 1191259701Sdim // is special cased. 1192259701Sdim bool SkipFirstExtraIndent = 1193288943Sdim (Previous && (Previous->opensScope() || 1194288943Sdim Previous->isOneOf(tok::semi, tok::kw_return) || 1195280031Sdim (Previous->getPrecedence() == prec::Assignment && 1196280031Sdim Style.AlignOperands) || 1197280031Sdim Previous->is(TT_ObjCMethodExpr))); 1198259701Sdim for (SmallVectorImpl<prec::Level>::const_reverse_iterator 1199259701Sdim I = Current.FakeLParens.rbegin(), 1200259701Sdim E = Current.FakeLParens.rend(); 1201259701Sdim I != E; ++I) { 1202259701Sdim ParenState NewParenState = State.Stack.back(); 1203341825Sdim NewParenState.Tok = nullptr; 1204259701Sdim NewParenState.ContainsLineBreak = false; 1205321369Sdim NewParenState.LastOperatorWrapped = true; 1206321369Sdim NewParenState.NoLineBreak = 1207321369Sdim NewParenState.NoLineBreak || State.Stack.back().NoLineBreakInOperand; 1208259701Sdim 1209321369Sdim // Don't propagate AvoidBinPacking into subexpressions of arg/param lists. 1210321369Sdim if (*I > prec::Comma) 1211321369Sdim NewParenState.AvoidBinPacking = false; 1212321369Sdim 1213280031Sdim // Indent from 'LastSpace' unless these are fake parentheses encapsulating 1214280031Sdim // a builder type call after 'return' or, if the alignment after opening 1215280031Sdim // brackets is disabled. 1216280031Sdim if (!Current.isTrailingComment() && 1217280031Sdim (Style.AlignOperands || *I < prec::Assignment) && 1218280031Sdim (!Previous || Previous->isNot(tok::kw_return) || 1219280031Sdim (Style.Language != FormatStyle::LK_Java && *I > 0)) && 1220296417Sdim (Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign || 1221296417Sdim *I != prec::Comma || Current.NestingLevel == 0)) 1222259701Sdim NewParenState.Indent = 1223259701Sdim std::max(std::max(State.Column, NewParenState.Indent), 1224259701Sdim State.Stack.back().LastSpace); 1225259701Sdim 1226259701Sdim // Do not indent relative to the fake parentheses inserted for "." or "->". 1227259701Sdim // This is a special case to make the following to statements consistent: 1228259701Sdim // OuterFunction(InnerFunctionCall( // break 1229259701Sdim // ParameterToInnerFunction)); 1230259701Sdim // OuterFunction(SomeObject.InnerFunctionCall( // break 1231259701Sdim // ParameterToInnerFunction)); 1232259701Sdim if (*I > prec::Unknown) 1233259701Sdim NewParenState.LastSpace = std::max(NewParenState.LastSpace, State.Column); 1234309124Sdim if (*I != prec::Conditional && !Current.is(TT_UnaryOperator) && 1235309124Sdim Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign) 1236280031Sdim NewParenState.StartOfFunctionCall = State.Column; 1237259701Sdim 1238259701Sdim // Always indent conditional expressions. Never indent expression where 1239259701Sdim // the 'operator' is ',', ';' or an assignment (i.e. *I <= 1240259701Sdim // prec::Assignment) as those have different indentation rules. Indent 1241259701Sdim // other expression, unless the indentation needs to be skipped. 1242259701Sdim if (*I == prec::Conditional || 1243259701Sdim (!SkipFirstExtraIndent && *I > prec::Assignment && 1244280031Sdim !Current.isTrailingComment())) 1245259701Sdim NewParenState.Indent += Style.ContinuationIndentWidth; 1246296417Sdim if ((Previous && !Previous->opensScope()) || *I != prec::Comma) 1247259701Sdim NewParenState.BreakBeforeParameter = false; 1248259701Sdim State.Stack.push_back(NewParenState); 1249259701Sdim SkipFirstExtraIndent = false; 1250259701Sdim } 1251276479Sdim} 1252259701Sdim 1253280031Sdimvoid ContinuationIndenter::moveStatePastFakeRParens(LineState &State) { 1254280031Sdim for (unsigned i = 0, e = State.NextToken->FakeRParens; i != e; ++i) { 1255276479Sdim unsigned VariablePos = State.Stack.back().VariablePos; 1256276479Sdim if (State.Stack.size() == 1) { 1257276479Sdim // Do not pop the last element. 1258276479Sdim break; 1259259701Sdim } 1260276479Sdim State.Stack.pop_back(); 1261276479Sdim State.Stack.back().VariablePos = VariablePos; 1262276479Sdim } 1263276479Sdim} 1264259701Sdim 1265276479Sdimvoid ContinuationIndenter::moveStatePastScopeOpener(LineState &State, 1266276479Sdim bool Newline) { 1267276479Sdim const FormatToken &Current = *State.NextToken; 1268276479Sdim if (!Current.opensScope()) 1269276479Sdim return; 1270276479Sdim 1271276479Sdim if (Current.MatchingParen && Current.BlockKind == BK_Block) { 1272276479Sdim moveStateToNewBlock(State); 1273276479Sdim return; 1274259701Sdim } 1275259701Sdim 1276276479Sdim unsigned NewIndent; 1277288943Sdim unsigned LastSpace = State.Stack.back().LastSpace; 1278276479Sdim bool AvoidBinPacking; 1279276479Sdim bool BreakBeforeParameter = false; 1280288943Sdim unsigned NestedBlockIndent = std::max(State.Stack.back().StartOfFunctionCall, 1281288943Sdim State.Stack.back().NestedBlockIndent); 1282321369Sdim if (Current.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) || 1283321369Sdim opensProtoMessageField(Current, Style)) { 1284296417Sdim if (Current.opensBlockOrBlockTypeList(Style)) { 1285321369Sdim NewIndent = Style.IndentWidth + 1286321369Sdim std::min(State.Column, State.Stack.back().NestedBlockIndent); 1287276479Sdim } else { 1288280031Sdim NewIndent = State.Stack.back().LastSpace + Style.ContinuationIndentWidth; 1289276479Sdim } 1290276479Sdim const FormatToken *NextNoComment = Current.getNextNonComment(); 1291296417Sdim bool EndsInComma = Current.MatchingParen && 1292296417Sdim Current.MatchingParen->Previous && 1293296417Sdim Current.MatchingParen->Previous->is(tok::comma); 1294327952Sdim AvoidBinPacking = EndsInComma || Current.is(TT_DictLiteral) || 1295327952Sdim Style.Language == FormatStyle::LK_Proto || 1296327952Sdim Style.Language == FormatStyle::LK_TextProto || 1297327952Sdim !Style.BinPackArguments || 1298327952Sdim (NextNoComment && 1299327952Sdim NextNoComment->isOneOf(TT_DesignatedInitializerPeriod, 1300327952Sdim TT_DesignatedInitializerLSquare)); 1301321369Sdim BreakBeforeParameter = EndsInComma; 1302288943Sdim if (Current.ParameterCount > 1) 1303288943Sdim NestedBlockIndent = std::max(NestedBlockIndent, State.Column + 1); 1304276479Sdim } else { 1305276479Sdim NewIndent = Style.ContinuationIndentWidth + 1306276479Sdim std::max(State.Stack.back().LastSpace, 1307276479Sdim State.Stack.back().StartOfFunctionCall); 1308288943Sdim 1309288943Sdim // Ensure that different different brackets force relative alignment, e.g.: 1310288943Sdim // void SomeFunction(vector< // break 1311288943Sdim // int> v); 1312288943Sdim // FIXME: We likely want to do this for more combinations of brackets. 1313321369Sdim if (Current.is(tok::less) && Current.ParentBracket == tok::l_paren) { 1314288943Sdim NewIndent = std::max(NewIndent, State.Stack.back().Indent); 1315288943Sdim LastSpace = std::max(LastSpace, State.Stack.back().Indent); 1316288943Sdim } 1317288943Sdim 1318321369Sdim bool EndsInComma = 1319321369Sdim Current.MatchingParen && 1320321369Sdim Current.MatchingParen->getPreviousNonComment() && 1321321369Sdim Current.MatchingParen->getPreviousNonComment()->is(tok::comma); 1322321369Sdim 1323341825Sdim // If ObjCBinPackProtocolList is unspecified, fall back to BinPackParameters 1324341825Sdim // for backwards compatibility. 1325341825Sdim bool ObjCBinPackProtocolList = 1326341825Sdim (Style.ObjCBinPackProtocolList == FormatStyle::BPS_Auto && 1327341825Sdim Style.BinPackParameters) || 1328341825Sdim Style.ObjCBinPackProtocolList == FormatStyle::BPS_Always; 1329341825Sdim 1330341825Sdim bool BinPackDeclaration = 1331341825Sdim (State.Line->Type != LT_ObjCDecl && Style.BinPackParameters) || 1332341825Sdim (State.Line->Type == LT_ObjCDecl && ObjCBinPackProtocolList); 1333341825Sdim 1334280031Sdim AvoidBinPacking = 1335321369Sdim (Style.Language == FormatStyle::LK_JavaScript && EndsInComma) || 1336341825Sdim (State.Line->MustBeDeclaration && !BinPackDeclaration) || 1337280031Sdim (!State.Line->MustBeDeclaration && !Style.BinPackArguments) || 1338280031Sdim (Style.ExperimentalAutoDetectBinPacking && 1339280031Sdim (Current.PackingKind == PPK_OnePerLine || 1340280031Sdim (!BinPackInconclusiveFunctions && 1341280031Sdim Current.PackingKind == PPK_Inconclusive))); 1342321369Sdim 1343288943Sdim if (Current.is(TT_ObjCMethodExpr) && Current.MatchingParen) { 1344288943Sdim if (Style.ColumnLimit) { 1345288943Sdim // If this '[' opens an ObjC call, determine whether all parameters fit 1346288943Sdim // into one line and put one per line if they don't. 1347341825Sdim if (getLengthToMatchingParen(Current, State.Stack) + State.Column > 1348276479Sdim getColumnLimit(State)) 1349288943Sdim BreakBeforeParameter = true; 1350288943Sdim } else { 1351288943Sdim // For ColumnLimit = 0, we have to figure out whether there is or has to 1352288943Sdim // be a line break within this call. 1353288943Sdim for (const FormatToken *Tok = &Current; 1354288943Sdim Tok && Tok != Current.MatchingParen; Tok = Tok->Next) { 1355288943Sdim if (Tok->MustBreakBefore || 1356288943Sdim (Tok->CanBreakBefore && Tok->NewlinesBefore > 0)) { 1357288943Sdim BreakBeforeParameter = true; 1358288943Sdim break; 1359288943Sdim } 1360288943Sdim } 1361288943Sdim } 1362288943Sdim } 1363321369Sdim 1364321369Sdim if (Style.Language == FormatStyle::LK_JavaScript && EndsInComma) 1365321369Sdim BreakBeforeParameter = true; 1366276479Sdim } 1367296417Sdim // Generally inherit NoLineBreak from the current scope to nested scope. 1368296417Sdim // However, don't do this for non-empty nested blocks, dict literals and 1369296417Sdim // array literals as these follow different indentation rules. 1370296417Sdim bool NoLineBreak = 1371296417Sdim Current.Children.empty() && 1372296417Sdim !Current.isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) && 1373296417Sdim (State.Stack.back().NoLineBreak || 1374321369Sdim State.Stack.back().NoLineBreakInOperand || 1375296417Sdim (Current.is(TT_TemplateOpener) && 1376321369Sdim State.Stack.back().ContainsUnwrappedBuilder)); 1377321369Sdim State.Stack.push_back( 1378341825Sdim ParenState(&Current, NewIndent, LastSpace, AvoidBinPacking, NoLineBreak)); 1379280031Sdim State.Stack.back().NestedBlockIndent = NestedBlockIndent; 1380276479Sdim State.Stack.back().BreakBeforeParameter = BreakBeforeParameter; 1381276479Sdim State.Stack.back().HasMultipleNestedBlocks = Current.BlockParameterCount > 1; 1382341825Sdim State.Stack.back().IsInsideObjCArrayLiteral = 1383341825Sdim Current.is(TT_ArrayInitializerLSquare) && Current.Previous && 1384341825Sdim Current.Previous->is(tok::at); 1385276479Sdim} 1386276479Sdim 1387276479Sdimvoid ContinuationIndenter::moveStatePastScopeCloser(LineState &State) { 1388276479Sdim const FormatToken &Current = *State.NextToken; 1389276479Sdim if (!Current.closesScope()) 1390276479Sdim return; 1391276479Sdim 1392259701Sdim // If we encounter a closing ), ], } or >, we can remove a level from our 1393259701Sdim // stacks. 1394259701Sdim if (State.Stack.size() > 1 && 1395321369Sdim (Current.isOneOf(tok::r_paren, tok::r_square, TT_TemplateString) || 1396259701Sdim (Current.is(tok::r_brace) && State.NextToken != State.Line->First) || 1397341825Sdim State.NextToken->is(TT_TemplateCloser) || 1398341825Sdim (Current.is(tok::greater) && Current.is(TT_DictLiteral)))) 1399259701Sdim State.Stack.pop_back(); 1400276479Sdim 1401341825Sdim // Reevaluate whether ObjC message arguments fit into one line. 1402341825Sdim // If a receiver spans multiple lines, e.g.: 1403341825Sdim // [[object block:^{ 1404341825Sdim // return 42; 1405341825Sdim // }] a:42 b:42]; 1406341825Sdim // BreakBeforeParameter is calculated based on an incorrect assumption 1407341825Sdim // (it is checked whether the whole expression fits into one line without 1408341825Sdim // considering a line break inside a message receiver). 1409341825Sdim // We check whether arguements fit after receiver scope closer (into the same 1410341825Sdim // line). 1411341825Sdim if (State.Stack.back().BreakBeforeParameter && Current.MatchingParen && 1412341825Sdim Current.MatchingParen->Previous) { 1413341825Sdim const FormatToken &CurrentScopeOpener = *Current.MatchingParen->Previous; 1414341825Sdim if (CurrentScopeOpener.is(TT_ObjCMethodExpr) && 1415341825Sdim CurrentScopeOpener.MatchingParen) { 1416341825Sdim int NecessarySpaceInLine = 1417341825Sdim getLengthToMatchingParen(CurrentScopeOpener, State.Stack) + 1418341825Sdim CurrentScopeOpener.TotalLength - Current.TotalLength - 1; 1419341825Sdim if (State.Column + Current.ColumnWidth + NecessarySpaceInLine <= 1420341825Sdim Style.ColumnLimit) 1421341825Sdim State.Stack.back().BreakBeforeParameter = false; 1422341825Sdim } 1423341825Sdim } 1424341825Sdim 1425259701Sdim if (Current.is(tok::r_square)) { 1426259701Sdim // If this ends the array subscript expr, reset the corresponding value. 1427259701Sdim const FormatToken *NextNonComment = Current.getNextNonComment(); 1428259701Sdim if (NextNonComment && NextNonComment->isNot(tok::l_square)) 1429259701Sdim State.Stack.back().StartOfArraySubscripts = 0; 1430259701Sdim } 1431276479Sdim} 1432259701Sdim 1433276479Sdimvoid ContinuationIndenter::moveStateToNewBlock(LineState &State) { 1434280031Sdim unsigned NestedBlockIndent = State.Stack.back().NestedBlockIndent; 1435280031Sdim // ObjC block sometimes follow special indentation rules. 1436280031Sdim unsigned NewIndent = 1437280031Sdim NestedBlockIndent + (State.NextToken->is(TT_ObjCBlockLBrace) 1438280031Sdim ? Style.ObjCBlockIndentWidth 1439280031Sdim : Style.IndentWidth); 1440341825Sdim State.Stack.push_back(ParenState(State.NextToken, NewIndent, 1441341825Sdim State.Stack.back().LastSpace, 1442321369Sdim /*AvoidBinPacking=*/true, 1443321369Sdim /*NoLineBreak=*/false)); 1444280031Sdim State.Stack.back().NestedBlockIndent = NestedBlockIndent; 1445276479Sdim State.Stack.back().BreakBeforeParameter = true; 1446259701Sdim} 1447259701Sdim 1448327952Sdimstatic unsigned getLastLineEndColumn(StringRef Text, unsigned StartColumn, 1449327952Sdim unsigned TabWidth, 1450327952Sdim encoding::Encoding Encoding) { 1451327952Sdim size_t LastNewlinePos = Text.find_last_of("\n"); 1452327952Sdim if (LastNewlinePos == StringRef::npos) { 1453327952Sdim return StartColumn + 1454327952Sdim encoding::columnWidthWithTabs(Text, StartColumn, TabWidth, Encoding); 1455327952Sdim } else { 1456327952Sdim return encoding::columnWidthWithTabs(Text.substr(LastNewlinePos), 1457327952Sdim /*StartColumn=*/0, TabWidth, Encoding); 1458327952Sdim } 1459327952Sdim} 1460327952Sdim 1461327952Sdimunsigned ContinuationIndenter::reformatRawStringLiteral( 1462327952Sdim const FormatToken &Current, LineState &State, 1463327952Sdim const FormatStyle &RawStringStyle, bool DryRun) { 1464327952Sdim unsigned StartColumn = State.Column - Current.ColumnWidth; 1465341825Sdim StringRef OldDelimiter = *getRawStringDelimiter(Current.TokenText); 1466341825Sdim StringRef NewDelimiter = 1467341825Sdim getCanonicalRawStringDelimiter(Style, RawStringStyle.Language); 1468341825Sdim if (NewDelimiter.empty() || OldDelimiter.empty()) 1469341825Sdim NewDelimiter = OldDelimiter; 1470327952Sdim // The text of a raw string is between the leading 'R"delimiter(' and the 1471327952Sdim // trailing 'delimiter)"'. 1472341825Sdim unsigned OldPrefixSize = 3 + OldDelimiter.size(); 1473341825Sdim unsigned OldSuffixSize = 2 + OldDelimiter.size(); 1474341825Sdim // We create a virtual text environment which expects a null-terminated 1475341825Sdim // string, so we cannot use StringRef. 1476341825Sdim std::string RawText = 1477341825Sdim Current.TokenText.substr(OldPrefixSize).drop_back(OldSuffixSize); 1478341825Sdim if (NewDelimiter != OldDelimiter) { 1479341825Sdim // Don't update to the canonical delimiter 'deli' if ')deli"' occurs in the 1480341825Sdim // raw string. 1481341825Sdim std::string CanonicalDelimiterSuffix = (")" + NewDelimiter + "\"").str(); 1482341825Sdim if (StringRef(RawText).contains(CanonicalDelimiterSuffix)) 1483341825Sdim NewDelimiter = OldDelimiter; 1484341825Sdim } 1485327952Sdim 1486341825Sdim unsigned NewPrefixSize = 3 + NewDelimiter.size(); 1487341825Sdim unsigned NewSuffixSize = 2 + NewDelimiter.size(); 1488327952Sdim 1489341825Sdim // The first start column is the column the raw text starts after formatting. 1490341825Sdim unsigned FirstStartColumn = StartColumn + NewPrefixSize; 1491341825Sdim 1492327952Sdim // The next start column is the intended indentation a line break inside 1493327952Sdim // the raw string at level 0. It is determined by the following rules: 1494327952Sdim // - if the content starts on newline, it is one level more than the current 1495327952Sdim // indent, and 1496327952Sdim // - if the content does not start on a newline, it is the first start 1497327952Sdim // column. 1498327952Sdim // These rules have the advantage that the formatted content both does not 1499327952Sdim // violate the rectangle rule and visually flows within the surrounding 1500327952Sdim // source. 1501341825Sdim bool ContentStartsOnNewline = Current.TokenText[OldPrefixSize] == '\n'; 1502341825Sdim unsigned NextStartColumn = 1503341825Sdim ContentStartsOnNewline 1504341825Sdim ? State.Stack.back().NestedBlockIndent + Style.IndentWidth 1505341825Sdim : FirstStartColumn; 1506327952Sdim 1507327952Sdim // The last start column is the column the raw string suffix starts if it is 1508327952Sdim // put on a newline. 1509327952Sdim // The last start column is the intended indentation of the raw string postfix 1510327952Sdim // if it is put on a newline. It is determined by the following rules: 1511327952Sdim // - if the raw string prefix starts on a newline, it is the column where 1512327952Sdim // that raw string prefix starts, and 1513327952Sdim // - if the raw string prefix does not start on a newline, it is the current 1514327952Sdim // indent. 1515327952Sdim unsigned LastStartColumn = Current.NewlinesBefore 1516341825Sdim ? FirstStartColumn - NewPrefixSize 1517341825Sdim : State.Stack.back().NestedBlockIndent; 1518327952Sdim 1519327952Sdim std::pair<tooling::Replacements, unsigned> Fixes = internal::reformat( 1520327952Sdim RawStringStyle, RawText, {tooling::Range(0, RawText.size())}, 1521327952Sdim FirstStartColumn, NextStartColumn, LastStartColumn, "<stdin>", 1522327952Sdim /*Status=*/nullptr); 1523327952Sdim 1524327952Sdim auto NewCode = applyAllReplacements(RawText, Fixes.first); 1525327952Sdim tooling::Replacements NoFixes; 1526327952Sdim if (!NewCode) { 1527327952Sdim State.Column += Current.ColumnWidth; 1528327952Sdim return 0; 1529327952Sdim } 1530327952Sdim if (!DryRun) { 1531341825Sdim if (NewDelimiter != OldDelimiter) { 1532341825Sdim // In 'R"delimiter(...', the delimiter starts 2 characters after the start 1533341825Sdim // of the token. 1534341825Sdim SourceLocation PrefixDelimiterStart = 1535341825Sdim Current.Tok.getLocation().getLocWithOffset(2); 1536341825Sdim auto PrefixErr = Whitespaces.addReplacement(tooling::Replacement( 1537341825Sdim SourceMgr, PrefixDelimiterStart, OldDelimiter.size(), NewDelimiter)); 1538341825Sdim if (PrefixErr) { 1539341825Sdim llvm::errs() 1540341825Sdim << "Failed to update the prefix delimiter of a raw string: " 1541341825Sdim << llvm::toString(std::move(PrefixErr)) << "\n"; 1542341825Sdim } 1543341825Sdim // In 'R"delimiter(...)delimiter"', the suffix delimiter starts at 1544341825Sdim // position length - 1 - |delimiter|. 1545341825Sdim SourceLocation SuffixDelimiterStart = 1546341825Sdim Current.Tok.getLocation().getLocWithOffset(Current.TokenText.size() - 1547341825Sdim 1 - OldDelimiter.size()); 1548341825Sdim auto SuffixErr = Whitespaces.addReplacement(tooling::Replacement( 1549341825Sdim SourceMgr, SuffixDelimiterStart, OldDelimiter.size(), NewDelimiter)); 1550341825Sdim if (SuffixErr) { 1551341825Sdim llvm::errs() 1552341825Sdim << "Failed to update the suffix delimiter of a raw string: " 1553341825Sdim << llvm::toString(std::move(SuffixErr)) << "\n"; 1554341825Sdim } 1555341825Sdim } 1556327952Sdim SourceLocation OriginLoc = 1557341825Sdim Current.Tok.getLocation().getLocWithOffset(OldPrefixSize); 1558327952Sdim for (const tooling::Replacement &Fix : Fixes.first) { 1559327952Sdim auto Err = Whitespaces.addReplacement(tooling::Replacement( 1560327952Sdim SourceMgr, OriginLoc.getLocWithOffset(Fix.getOffset()), 1561327952Sdim Fix.getLength(), Fix.getReplacementText())); 1562327952Sdim if (Err) { 1563327952Sdim llvm::errs() << "Failed to reformat raw string: " 1564327952Sdim << llvm::toString(std::move(Err)) << "\n"; 1565327952Sdim } 1566327952Sdim } 1567327952Sdim } 1568327952Sdim unsigned RawLastLineEndColumn = getLastLineEndColumn( 1569327952Sdim *NewCode, FirstStartColumn, Style.TabWidth, Encoding); 1570341825Sdim State.Column = RawLastLineEndColumn + NewSuffixSize; 1571341825Sdim // Since we're updating the column to after the raw string literal here, we 1572341825Sdim // have to manually add the penalty for the prefix R"delim( over the column 1573341825Sdim // limit. 1574341825Sdim unsigned PrefixExcessCharacters = 1575341825Sdim StartColumn + NewPrefixSize > Style.ColumnLimit ? 1576341825Sdim StartColumn + NewPrefixSize - Style.ColumnLimit : 0; 1577341825Sdim return Fixes.second + PrefixExcessCharacters * Style.PenaltyExcessCharacter; 1578327952Sdim} 1579327952Sdim 1580259701Sdimunsigned ContinuationIndenter::addMultilineToken(const FormatToken &Current, 1581259701Sdim LineState &State) { 1582259701Sdim // Break before further function parameters on all levels. 1583259701Sdim for (unsigned i = 0, e = State.Stack.size(); i != e; ++i) 1584259701Sdim State.Stack[i].BreakBeforeParameter = true; 1585259701Sdim 1586259701Sdim unsigned ColumnsUsed = State.Column; 1587259701Sdim // We can only affect layout of the first and the last line, so the penalty 1588259701Sdim // for all other lines is constant, and we ignore it. 1589259701Sdim State.Column = Current.LastLineColumnWidth; 1590259701Sdim 1591259701Sdim if (ColumnsUsed > getColumnLimit(State)) 1592259701Sdim return Style.PenaltyExcessCharacter * (ColumnsUsed - getColumnLimit(State)); 1593259701Sdim return 0; 1594259701Sdim} 1595259701Sdim 1596327952Sdimunsigned ContinuationIndenter::handleEndOfLine(const FormatToken &Current, 1597327952Sdim LineState &State, bool DryRun, 1598327952Sdim bool AllowBreak) { 1599327952Sdim unsigned Penalty = 0; 1600327952Sdim // Compute the raw string style to use in case this is a raw string literal 1601327952Sdim // that can be reformatted. 1602327952Sdim auto RawStringStyle = getRawStringStyle(Current, State); 1603341825Sdim if (RawStringStyle && !Current.Finalized) { 1604327952Sdim Penalty = reformatRawStringLiteral(Current, State, *RawStringStyle, DryRun); 1605327952Sdim } else if (Current.IsMultiline && Current.isNot(TT_BlockComment)) { 1606327952Sdim // Don't break multi-line tokens other than block comments and raw string 1607327952Sdim // literals. Instead, just update the state. 1608327952Sdim Penalty = addMultilineToken(Current, State); 1609327952Sdim } else if (State.Line->Type != LT_ImportStatement) { 1610327952Sdim // We generally don't break import statements. 1611327952Sdim LineState OriginalState = State; 1612259701Sdim 1613327952Sdim // Whether we force the reflowing algorithm to stay strictly within the 1614327952Sdim // column limit. 1615327952Sdim bool Strict = false; 1616327952Sdim // Whether the first non-strict attempt at reflowing did intentionally 1617327952Sdim // exceed the column limit. 1618327952Sdim bool Exceeded = false; 1619327952Sdim std::tie(Penalty, Exceeded) = breakProtrudingToken( 1620327952Sdim Current, State, AllowBreak, /*DryRun=*/true, Strict); 1621327952Sdim if (Exceeded) { 1622327952Sdim // If non-strict reflowing exceeds the column limit, try whether strict 1623327952Sdim // reflowing leads to an overall lower penalty. 1624327952Sdim LineState StrictState = OriginalState; 1625327952Sdim unsigned StrictPenalty = 1626327952Sdim breakProtrudingToken(Current, StrictState, AllowBreak, 1627327952Sdim /*DryRun=*/true, /*Strict=*/true) 1628327952Sdim .first; 1629327952Sdim Strict = StrictPenalty <= Penalty; 1630327952Sdim if (Strict) { 1631327952Sdim Penalty = StrictPenalty; 1632327952Sdim State = StrictState; 1633327952Sdim } 1634327952Sdim } 1635327952Sdim if (!DryRun) { 1636327952Sdim // If we're not in dry-run mode, apply the changes with the decision on 1637327952Sdim // strictness made above. 1638327952Sdim breakProtrudingToken(Current, OriginalState, AllowBreak, /*DryRun=*/false, 1639327952Sdim Strict); 1640327952Sdim } 1641327952Sdim } 1642327952Sdim if (State.Column > getColumnLimit(State)) { 1643327952Sdim unsigned ExcessCharacters = State.Column - getColumnLimit(State); 1644327952Sdim Penalty += Style.PenaltyExcessCharacter * ExcessCharacters; 1645327952Sdim } 1646327952Sdim return Penalty; 1647327952Sdim} 1648259701Sdim 1649341825Sdim// Returns the enclosing function name of a token, or the empty string if not 1650341825Sdim// found. 1651341825Sdimstatic StringRef getEnclosingFunctionName(const FormatToken &Current) { 1652341825Sdim // Look for: 'function(' or 'function<templates>(' before Current. 1653341825Sdim auto Tok = Current.getPreviousNonComment(); 1654341825Sdim if (!Tok || !Tok->is(tok::l_paren)) 1655341825Sdim return ""; 1656341825Sdim Tok = Tok->getPreviousNonComment(); 1657341825Sdim if (!Tok) 1658341825Sdim return ""; 1659341825Sdim if (Tok->is(TT_TemplateCloser)) { 1660341825Sdim Tok = Tok->MatchingParen; 1661341825Sdim if (Tok) 1662341825Sdim Tok = Tok->getPreviousNonComment(); 1663341825Sdim } 1664341825Sdim if (!Tok || !Tok->is(tok::identifier)) 1665341825Sdim return ""; 1666341825Sdim return Tok->TokenText; 1667341825Sdim} 1668341825Sdim 1669327952Sdimllvm::Optional<FormatStyle> 1670327952SdimContinuationIndenter::getRawStringStyle(const FormatToken &Current, 1671327952Sdim const LineState &State) { 1672327952Sdim if (!Current.isStringLiteral()) 1673327952Sdim return None; 1674327952Sdim auto Delimiter = getRawStringDelimiter(Current.TokenText); 1675327952Sdim if (!Delimiter) 1676327952Sdim return None; 1677341825Sdim auto RawStringStyle = RawStringFormats.getDelimiterStyle(*Delimiter); 1678341825Sdim if (!RawStringStyle && Delimiter->empty()) 1679341825Sdim RawStringStyle = RawStringFormats.getEnclosingFunctionStyle( 1680341825Sdim getEnclosingFunctionName(Current)); 1681327952Sdim if (!RawStringStyle) 1682327952Sdim return None; 1683327952Sdim RawStringStyle->ColumnLimit = getColumnLimit(State); 1684327952Sdim return RawStringStyle; 1685327952Sdim} 1686259701Sdim 1687327952Sdimstd::unique_ptr<BreakableToken> ContinuationIndenter::createBreakableToken( 1688327952Sdim const FormatToken &Current, LineState &State, bool AllowBreak) { 1689259701Sdim unsigned StartColumn = State.Column - Current.ColumnWidth; 1690276479Sdim if (Current.isStringLiteral()) { 1691280031Sdim // FIXME: String literal breaking is currently disabled for Java and JS, as 1692280031Sdim // it requires strings to be merged using "+" which we don't support. 1693280031Sdim if (Style.Language == FormatStyle::LK_Java || 1694309124Sdim Style.Language == FormatStyle::LK_JavaScript || 1695327952Sdim !Style.BreakStringLiterals || 1696327952Sdim !AllowBreak) 1697327952Sdim return nullptr; 1698280031Sdim 1699259701Sdim // Don't break string literals inside preprocessor directives (except for 1700259701Sdim // #define directives, as their contents are stored in separate lines and 1701259701Sdim // are not affected by this check). 1702259701Sdim // This way we avoid breaking code with line directives and unknown 1703259701Sdim // preprocessor directives that contain long string literals. 1704259701Sdim if (State.Line->Type == LT_PreprocessorDirective) 1705327952Sdim return nullptr; 1706259701Sdim // Exempts unterminated string literals from line breaking. The user will 1707259701Sdim // likely want to terminate the string before any line breaking is done. 1708259701Sdim if (Current.IsUnterminatedLiteral) 1709327952Sdim return nullptr; 1710341825Sdim // Don't break string literals inside Objective-C array literals (doing so 1711341825Sdim // raises the warning -Wobjc-string-concatenation). 1712341825Sdim if (State.Stack.back().IsInsideObjCArrayLiteral) { 1713341825Sdim return nullptr; 1714341825Sdim } 1715259701Sdim 1716259701Sdim StringRef Text = Current.TokenText; 1717259701Sdim StringRef Prefix; 1718259701Sdim StringRef Postfix; 1719259701Sdim // FIXME: Handle whitespace between '_T', '(', '"..."', and ')'. 1720259701Sdim // FIXME: Store Prefix and Suffix (or PrefixLength and SuffixLength to 1721259701Sdim // reduce the overhead) for each FormatToken, which is a string, so that we 1722259701Sdim // don't run multiple checks here on the hot path. 1723259701Sdim if ((Text.endswith(Postfix = "\"") && 1724321369Sdim (Text.startswith(Prefix = "@\"") || Text.startswith(Prefix = "\"") || 1725276479Sdim Text.startswith(Prefix = "u\"") || Text.startswith(Prefix = "U\"") || 1726276479Sdim Text.startswith(Prefix = "u8\"") || 1727259701Sdim Text.startswith(Prefix = "L\""))) || 1728280031Sdim (Text.startswith(Prefix = "_T(\"") && Text.endswith(Postfix = "\")"))) { 1729341825Sdim // We need this to address the case where there is an unbreakable tail 1730341825Sdim // only if certain other formatting decisions have been taken. The 1731341825Sdim // UnbreakableTailLength of Current is an overapproximation is that case 1732341825Sdim // and we need to be correct here. 1733341825Sdim unsigned UnbreakableTailLength = (State.NextToken && canBreak(State)) 1734341825Sdim ? 0 1735341825Sdim : Current.UnbreakableTailLength; 1736327952Sdim return llvm::make_unique<BreakableStringLiteral>( 1737341825Sdim Current, StartColumn, Prefix, Postfix, UnbreakableTailLength, 1738341825Sdim State.Line->InPPDirective, Encoding, Style); 1739259701Sdim } 1740309124Sdim } else if (Current.is(TT_BlockComment)) { 1741327952Sdim if (!Style.ReflowComments || 1742321369Sdim // If a comment token switches formatting, like 1743321369Sdim // /* clang-format on */, we don't want to break it further, 1744321369Sdim // but we may still want to adjust its indentation. 1745327952Sdim switchesFormatting(Current)) { 1746327952Sdim return nullptr; 1747327952Sdim } 1748327952Sdim return llvm::make_unique<BreakableBlockComment>( 1749321369Sdim Current, StartColumn, Current.OriginalColumn, !Current.Previous, 1750327952Sdim State.Line->InPPDirective, Encoding, Style); 1751280031Sdim } else if (Current.is(TT_LineComment) && 1752276479Sdim (Current.Previous == nullptr || 1753280031Sdim Current.Previous->isNot(TT_ImplicitStringLiteral))) { 1754296417Sdim if (!Style.ReflowComments || 1755321369Sdim CommentPragmasRegex.match(Current.TokenText.substr(2)) || 1756321369Sdim switchesFormatting(Current)) 1757327952Sdim return nullptr; 1758327952Sdim return llvm::make_unique<BreakableLineCommentSection>( 1759321369Sdim Current, StartColumn, Current.OriginalColumn, !Current.Previous, 1760327952Sdim /*InPPDirective=*/false, Encoding, Style); 1761327952Sdim } 1762327952Sdim return nullptr; 1763327952Sdim} 1764327952Sdim 1765327952Sdimstd::pair<unsigned, bool> 1766327952SdimContinuationIndenter::breakProtrudingToken(const FormatToken &Current, 1767327952Sdim LineState &State, bool AllowBreak, 1768327952Sdim bool DryRun, bool Strict) { 1769327952Sdim std::unique_ptr<const BreakableToken> Token = 1770327952Sdim createBreakableToken(Current, State, AllowBreak); 1771327952Sdim if (!Token) 1772327952Sdim return {0, false}; 1773327952Sdim assert(Token->getLineCount() > 0); 1774327952Sdim unsigned ColumnLimit = getColumnLimit(State); 1775327952Sdim if (Current.is(TT_LineComment)) { 1776259701Sdim // We don't insert backslashes when breaking line comments. 1777259701Sdim ColumnLimit = Style.ColumnLimit; 1778259701Sdim } 1779259701Sdim if (Current.UnbreakableTailLength >= ColumnLimit) 1780327952Sdim return {0, false}; 1781327952Sdim // ColumnWidth was already accounted into State.Column before calling 1782327952Sdim // breakProtrudingToken. 1783327952Sdim unsigned StartColumn = State.Column - Current.ColumnWidth; 1784327952Sdim unsigned NewBreakPenalty = Current.isStringLiteral() 1785327952Sdim ? Style.PenaltyBreakString 1786327952Sdim : Style.PenaltyBreakComment; 1787327952Sdim // Stores whether we intentionally decide to let a line exceed the column 1788327952Sdim // limit. 1789327952Sdim bool Exceeded = false; 1790327952Sdim // Stores whether we introduce a break anywhere in the token. 1791327952Sdim bool BreakInserted = Token->introducesBreakBeforeToken(); 1792327952Sdim // Store whether we inserted a new line break at the end of the previous 1793327952Sdim // logical line. 1794327952Sdim bool NewBreakBefore = false; 1795321369Sdim // We use a conservative reflowing strategy. Reflow starts after a line is 1796321369Sdim // broken or the corresponding whitespace compressed. Reflow ends as soon as a 1797321369Sdim // line that doesn't get reflown with the previous line is reached. 1798327952Sdim bool Reflow = false; 1799327952Sdim // Keep track of where we are in the token: 1800327952Sdim // Where we are in the content of the current logical line. 1801327952Sdim unsigned TailOffset = 0; 1802327952Sdim // The column number we're currently at. 1803327952Sdim unsigned ContentStartColumn = 1804327952Sdim Token->getContentStartColumn(0, /*Break=*/false); 1805327952Sdim // The number of columns left in the current logical line after TailOffset. 1806327952Sdim unsigned RemainingTokenColumns = 1807327952Sdim Token->getRemainingLength(0, TailOffset, ContentStartColumn); 1808327952Sdim // Adapt the start of the token, for example indent. 1809327952Sdim if (!DryRun) 1810327952Sdim Token->adaptStartOfLine(0, Whitespaces); 1811327952Sdim 1812341825Sdim unsigned ContentIndent = 0; 1813259701Sdim unsigned Penalty = 0; 1814341825Sdim LLVM_DEBUG(llvm::dbgs() << "Breaking protruding token at column " 1815341825Sdim << StartColumn << ".\n"); 1816259701Sdim for (unsigned LineIndex = 0, EndIndex = Token->getLineCount(); 1817259701Sdim LineIndex != EndIndex; ++LineIndex) { 1818341825Sdim LLVM_DEBUG(llvm::dbgs() 1819341825Sdim << " Line: " << LineIndex << " (Reflow: " << Reflow << ")\n"); 1820327952Sdim NewBreakBefore = false; 1821327952Sdim // If we did reflow the previous line, we'll try reflowing again. Otherwise 1822327952Sdim // we'll start reflowing if the current line is broken or whitespace is 1823327952Sdim // compressed. 1824327952Sdim bool TryReflow = Reflow; 1825327952Sdim // Break the current token until we can fit the rest of the line. 1826327952Sdim while (ContentStartColumn + RemainingTokenColumns > ColumnLimit) { 1827341825Sdim LLVM_DEBUG(llvm::dbgs() << " Over limit, need: " 1828341825Sdim << (ContentStartColumn + RemainingTokenColumns) 1829341825Sdim << ", space: " << ColumnLimit 1830341825Sdim << ", reflown prefix: " << ContentStartColumn 1831341825Sdim << ", offset in line: " << TailOffset << "\n"); 1832327952Sdim // If the current token doesn't fit, find the latest possible split in the 1833327952Sdim // current line so that breaking at it will be under the column limit. 1834327952Sdim // FIXME: Use the earliest possible split while reflowing to correctly 1835327952Sdim // compress whitespace within a line. 1836327952Sdim BreakableToken::Split Split = 1837327952Sdim Token->getSplit(LineIndex, TailOffset, ColumnLimit, 1838327952Sdim ContentStartColumn, CommentPragmasRegex); 1839259701Sdim if (Split.first == StringRef::npos) { 1840327952Sdim // No break opportunity - update the penalty and continue with the next 1841327952Sdim // logical line. 1842259701Sdim if (LineIndex < EndIndex - 1) 1843327952Sdim // The last line's penalty is handled in addNextStateToQueue(). 1844259701Sdim Penalty += Style.PenaltyExcessCharacter * 1845327952Sdim (ContentStartColumn + RemainingTokenColumns - ColumnLimit); 1846341825Sdim LLVM_DEBUG(llvm::dbgs() << " No break opportunity.\n"); 1847259701Sdim break; 1848259701Sdim } 1849259701Sdim assert(Split.first != 0); 1850259701Sdim 1851327952Sdim if (Token->supportsReflow()) { 1852327952Sdim // Check whether the next natural split point after the current one can 1853327952Sdim // still fit the line, either because we can compress away whitespace, 1854327952Sdim // or because the penalty the excess characters introduce is lower than 1855327952Sdim // the break penalty. 1856327952Sdim // We only do this for tokens that support reflowing, and thus allow us 1857327952Sdim // to change the whitespace arbitrarily (e.g. comments). 1858327952Sdim // Other tokens, like string literals, can be broken on arbitrary 1859327952Sdim // positions. 1860327952Sdim 1861327952Sdim // First, compute the columns from TailOffset to the next possible split 1862327952Sdim // position. 1863327952Sdim // For example: 1864327952Sdim // ColumnLimit: | 1865327952Sdim // // Some text that breaks 1866327952Sdim // ^ tail offset 1867327952Sdim // ^-- split 1868327952Sdim // ^-------- to split columns 1869327952Sdim // ^--- next split 1870327952Sdim // ^--------------- to next split columns 1871327952Sdim unsigned ToSplitColumns = Token->getRangeLength( 1872327952Sdim LineIndex, TailOffset, Split.first, ContentStartColumn); 1873341825Sdim LLVM_DEBUG(llvm::dbgs() << " ToSplit: " << ToSplitColumns << "\n"); 1874327952Sdim 1875327952Sdim BreakableToken::Split NextSplit = Token->getSplit( 1876327952Sdim LineIndex, TailOffset + Split.first + Split.second, ColumnLimit, 1877327952Sdim ContentStartColumn + ToSplitColumns + 1, CommentPragmasRegex); 1878327952Sdim // Compute the columns necessary to fit the next non-breakable sequence 1879327952Sdim // into the current line. 1880327952Sdim unsigned ToNextSplitColumns = 0; 1881327952Sdim if (NextSplit.first == StringRef::npos) { 1882327952Sdim ToNextSplitColumns = Token->getRemainingLength(LineIndex, TailOffset, 1883327952Sdim ContentStartColumn); 1884327952Sdim } else { 1885327952Sdim ToNextSplitColumns = Token->getRangeLength( 1886327952Sdim LineIndex, TailOffset, 1887327952Sdim Split.first + Split.second + NextSplit.first, ContentStartColumn); 1888327952Sdim } 1889327952Sdim // Compress the whitespace between the break and the start of the next 1890327952Sdim // unbreakable sequence. 1891327952Sdim ToNextSplitColumns = 1892327952Sdim Token->getLengthAfterCompression(ToNextSplitColumns, Split); 1893341825Sdim LLVM_DEBUG(llvm::dbgs() 1894341825Sdim << " ContentStartColumn: " << ContentStartColumn << "\n"); 1895341825Sdim LLVM_DEBUG(llvm::dbgs() 1896341825Sdim << " ToNextSplit: " << ToNextSplitColumns << "\n"); 1897327952Sdim // If the whitespace compression makes us fit, continue on the current 1898327952Sdim // line. 1899327952Sdim bool ContinueOnLine = 1900327952Sdim ContentStartColumn + ToNextSplitColumns <= ColumnLimit; 1901327952Sdim unsigned ExcessCharactersPenalty = 0; 1902327952Sdim if (!ContinueOnLine && !Strict) { 1903327952Sdim // Similarly, if the excess characters' penalty is lower than the 1904327952Sdim // penalty of introducing a new break, continue on the current line. 1905327952Sdim ExcessCharactersPenalty = 1906327952Sdim (ContentStartColumn + ToNextSplitColumns - ColumnLimit) * 1907327952Sdim Style.PenaltyExcessCharacter; 1908341825Sdim LLVM_DEBUG(llvm::dbgs() 1909341825Sdim << " Penalty excess: " << ExcessCharactersPenalty 1910341825Sdim << "\n break : " << NewBreakPenalty << "\n"); 1911327952Sdim if (ExcessCharactersPenalty < NewBreakPenalty) { 1912327952Sdim Exceeded = true; 1913327952Sdim ContinueOnLine = true; 1914327952Sdim } 1915327952Sdim } 1916327952Sdim if (ContinueOnLine) { 1917341825Sdim LLVM_DEBUG(llvm::dbgs() << " Continuing on line...\n"); 1918327952Sdim // The current line fits after compressing the whitespace - reflow 1919327952Sdim // the next line into it if possible. 1920327952Sdim TryReflow = true; 1921327952Sdim if (!DryRun) 1922327952Sdim Token->compressWhitespace(LineIndex, TailOffset, Split, 1923327952Sdim Whitespaces); 1924327952Sdim // When we continue on the same line, leave one space between content. 1925327952Sdim ContentStartColumn += ToSplitColumns + 1; 1926327952Sdim Penalty += ExcessCharactersPenalty; 1927327952Sdim TailOffset += Split.first + Split.second; 1928327952Sdim RemainingTokenColumns = Token->getRemainingLength( 1929327952Sdim LineIndex, TailOffset, ContentStartColumn); 1930327952Sdim continue; 1931327952Sdim } 1932259701Sdim } 1933341825Sdim LLVM_DEBUG(llvm::dbgs() << " Breaking...\n"); 1934341825Sdim // Update the ContentIndent only if the current line was not reflown with 1935341825Sdim // the previous line, since in that case the previous line should still 1936341825Sdim // determine the ContentIndent. Also never intent the last line. 1937341825Sdim if (!Reflow) 1938341825Sdim ContentIndent = Token->getContentIndent(LineIndex); 1939341825Sdim LLVM_DEBUG(llvm::dbgs() 1940341825Sdim << " ContentIndent: " << ContentIndent << "\n"); 1941341825Sdim ContentStartColumn = ContentIndent + Token->getContentStartColumn( 1942341825Sdim LineIndex, /*Break=*/true); 1943341825Sdim 1944327952Sdim unsigned NewRemainingTokenColumns = Token->getRemainingLength( 1945327952Sdim LineIndex, TailOffset + Split.first + Split.second, 1946327952Sdim ContentStartColumn); 1947341825Sdim if (NewRemainingTokenColumns == 0) { 1948341825Sdim // No content to indent. 1949341825Sdim ContentIndent = 0; 1950341825Sdim ContentStartColumn = 1951341825Sdim Token->getContentStartColumn(LineIndex, /*Break=*/true); 1952341825Sdim NewRemainingTokenColumns = Token->getRemainingLength( 1953341825Sdim LineIndex, TailOffset + Split.first + Split.second, 1954341825Sdim ContentStartColumn); 1955341825Sdim } 1956259701Sdim 1957276479Sdim // When breaking before a tab character, it may be moved by a few columns, 1958276479Sdim // but will still be expanded to the next tab stop, so we don't save any 1959276479Sdim // columns. 1960327952Sdim if (NewRemainingTokenColumns == RemainingTokenColumns) { 1961327952Sdim // FIXME: Do we need to adjust the penalty? 1962276479Sdim break; 1963327952Sdim } 1964327952Sdim assert(NewRemainingTokenColumns < RemainingTokenColumns); 1965276479Sdim 1966341825Sdim LLVM_DEBUG(llvm::dbgs() << " Breaking at: " << TailOffset + Split.first 1967341825Sdim << ", " << Split.second << "\n"); 1968259701Sdim if (!DryRun) 1969341825Sdim Token->insertBreak(LineIndex, TailOffset, Split, ContentIndent, 1970341825Sdim Whitespaces); 1971327952Sdim 1972327952Sdim Penalty += NewBreakPenalty; 1973259701Sdim TailOffset += Split.first + Split.second; 1974259701Sdim RemainingTokenColumns = NewRemainingTokenColumns; 1975259701Sdim BreakInserted = true; 1976327952Sdim NewBreakBefore = true; 1977259701Sdim } 1978327952Sdim // In case there's another line, prepare the state for the start of the next 1979327952Sdim // line. 1980327952Sdim if (LineIndex + 1 != EndIndex) { 1981327952Sdim unsigned NextLineIndex = LineIndex + 1; 1982327952Sdim if (NewBreakBefore) 1983327952Sdim // After breaking a line, try to reflow the next line into the current 1984327952Sdim // one once RemainingTokenColumns fits. 1985327952Sdim TryReflow = true; 1986327952Sdim if (TryReflow) { 1987327952Sdim // We decided that we want to try reflowing the next line into the 1988327952Sdim // current one. 1989327952Sdim // We will now adjust the state as if the reflow is successful (in 1990327952Sdim // preparation for the next line), and see whether that works. If we 1991327952Sdim // decide that we cannot reflow, we will later reset the state to the 1992327952Sdim // start of the next line. 1993327952Sdim Reflow = false; 1994327952Sdim // As we did not continue breaking the line, RemainingTokenColumns is 1995327952Sdim // known to fit after ContentStartColumn. Adapt ContentStartColumn to 1996327952Sdim // the position at which we want to format the next line if we do 1997327952Sdim // actually reflow. 1998327952Sdim // When we reflow, we need to add a space between the end of the current 1999327952Sdim // line and the next line's start column. 2000327952Sdim ContentStartColumn += RemainingTokenColumns + 1; 2001327952Sdim // Get the split that we need to reflow next logical line into the end 2002327952Sdim // of the current one; the split will include any leading whitespace of 2003327952Sdim // the next logical line. 2004327952Sdim BreakableToken::Split SplitBeforeNext = 2005327952Sdim Token->getReflowSplit(NextLineIndex, CommentPragmasRegex); 2006341825Sdim LLVM_DEBUG(llvm::dbgs() 2007341825Sdim << " Size of reflown text: " << ContentStartColumn 2008341825Sdim << "\n Potential reflow split: "); 2009327952Sdim if (SplitBeforeNext.first != StringRef::npos) { 2010341825Sdim LLVM_DEBUG(llvm::dbgs() << SplitBeforeNext.first << ", " 2011341825Sdim << SplitBeforeNext.second << "\n"); 2012327952Sdim TailOffset = SplitBeforeNext.first + SplitBeforeNext.second; 2013327952Sdim // If the rest of the next line fits into the current line below the 2014327952Sdim // column limit, we can safely reflow. 2015327952Sdim RemainingTokenColumns = Token->getRemainingLength( 2016327952Sdim NextLineIndex, TailOffset, ContentStartColumn); 2017327952Sdim Reflow = true; 2018327952Sdim if (ContentStartColumn + RemainingTokenColumns > ColumnLimit) { 2019341825Sdim LLVM_DEBUG(llvm::dbgs() 2020341825Sdim << " Over limit after reflow, need: " 2021341825Sdim << (ContentStartColumn + RemainingTokenColumns) 2022341825Sdim << ", space: " << ColumnLimit 2023341825Sdim << ", reflown prefix: " << ContentStartColumn 2024341825Sdim << ", offset in line: " << TailOffset << "\n"); 2025327952Sdim // If the whole next line does not fit, try to find a point in 2026327952Sdim // the next line at which we can break so that attaching the part 2027327952Sdim // of the next line to that break point onto the current line is 2028327952Sdim // below the column limit. 2029327952Sdim BreakableToken::Split Split = 2030327952Sdim Token->getSplit(NextLineIndex, TailOffset, ColumnLimit, 2031327952Sdim ContentStartColumn, CommentPragmasRegex); 2032327952Sdim if (Split.first == StringRef::npos) { 2033341825Sdim LLVM_DEBUG(llvm::dbgs() << " Did not find later break\n"); 2034327952Sdim Reflow = false; 2035327952Sdim } else { 2036327952Sdim // Check whether the first split point gets us below the column 2037327952Sdim // limit. Note that we will execute this split below as part of 2038327952Sdim // the normal token breaking and reflow logic within the line. 2039327952Sdim unsigned ToSplitColumns = Token->getRangeLength( 2040327952Sdim NextLineIndex, TailOffset, Split.first, ContentStartColumn); 2041327952Sdim if (ContentStartColumn + ToSplitColumns > ColumnLimit) { 2042341825Sdim LLVM_DEBUG(llvm::dbgs() << " Next split protrudes, need: " 2043341825Sdim << (ContentStartColumn + ToSplitColumns) 2044341825Sdim << ", space: " << ColumnLimit); 2045327952Sdim unsigned ExcessCharactersPenalty = 2046327952Sdim (ContentStartColumn + ToSplitColumns - ColumnLimit) * 2047327952Sdim Style.PenaltyExcessCharacter; 2048327952Sdim if (NewBreakPenalty < ExcessCharactersPenalty) { 2049327952Sdim Reflow = false; 2050327952Sdim } 2051327952Sdim } 2052327952Sdim } 2053327952Sdim } 2054327952Sdim } else { 2055341825Sdim LLVM_DEBUG(llvm::dbgs() << "not found.\n"); 2056327952Sdim } 2057327952Sdim } 2058327952Sdim if (!Reflow) { 2059327952Sdim // If we didn't reflow into the next line, the only space to consider is 2060327952Sdim // the next logical line. Reset our state to match the start of the next 2061327952Sdim // line. 2062327952Sdim TailOffset = 0; 2063327952Sdim ContentStartColumn = 2064327952Sdim Token->getContentStartColumn(NextLineIndex, /*Break=*/false); 2065327952Sdim RemainingTokenColumns = Token->getRemainingLength( 2066327952Sdim NextLineIndex, TailOffset, ContentStartColumn); 2067327952Sdim // Adapt the start of the token, for example indent. 2068327952Sdim if (!DryRun) 2069327952Sdim Token->adaptStartOfLine(NextLineIndex, Whitespaces); 2070327952Sdim } else { 2071327952Sdim // If we found a reflow split and have added a new break before the next 2072327952Sdim // line, we are going to remove the line break at the start of the next 2073327952Sdim // logical line. For example, here we'll add a new line break after 2074327952Sdim // 'text', and subsequently delete the line break between 'that' and 2075327952Sdim // 'reflows'. 2076327952Sdim // // some text that 2077327952Sdim // // reflows 2078327952Sdim // -> 2079327952Sdim // // some text 2080327952Sdim // // that reflows 2081327952Sdim // When adding the line break, we also added the penalty for it, so we 2082327952Sdim // need to subtract that penalty again when we remove the line break due 2083327952Sdim // to reflowing. 2084327952Sdim if (NewBreakBefore) { 2085327952Sdim assert(Penalty >= NewBreakPenalty); 2086327952Sdim Penalty -= NewBreakPenalty; 2087327952Sdim } 2088327952Sdim if (!DryRun) 2089327952Sdim Token->reflow(NextLineIndex, Whitespaces); 2090327952Sdim } 2091327952Sdim } 2092259701Sdim } 2093259701Sdim 2094327952Sdim BreakableToken::Split SplitAfterLastLine = 2095327952Sdim Token->getSplitAfterLastLine(TailOffset); 2096327952Sdim if (SplitAfterLastLine.first != StringRef::npos) { 2097341825Sdim LLVM_DEBUG(llvm::dbgs() << "Replacing whitespace after last line.\n"); 2098327952Sdim if (!DryRun) 2099327952Sdim Token->replaceWhitespaceAfterLastLine(TailOffset, SplitAfterLastLine, 2100327952Sdim Whitespaces); 2101327952Sdim ContentStartColumn = 2102327952Sdim Token->getContentStartColumn(Token->getLineCount() - 1, /*Break=*/true); 2103327952Sdim RemainingTokenColumns = Token->getRemainingLength( 2104327952Sdim Token->getLineCount() - 1, 2105327952Sdim TailOffset + SplitAfterLastLine.first + SplitAfterLastLine.second, 2106327952Sdim ContentStartColumn); 2107327952Sdim } 2108259701Sdim 2109327952Sdim State.Column = ContentStartColumn + RemainingTokenColumns - 2110327952Sdim Current.UnbreakableTailLength; 2111327952Sdim 2112259701Sdim if (BreakInserted) { 2113259701Sdim // If we break the token inside a parameter list, we need to break before 2114259701Sdim // the next parameter on all levels, so that the next parameter is clearly 2115259701Sdim // visible. Line comments already introduce a break. 2116280031Sdim if (Current.isNot(TT_LineComment)) { 2117259701Sdim for (unsigned i = 0, e = State.Stack.size(); i != e; ++i) 2118259701Sdim State.Stack[i].BreakBeforeParameter = true; 2119259701Sdim } 2120259701Sdim 2121327952Sdim if (Current.is(TT_BlockComment)) 2122327952Sdim State.NoContinuation = true; 2123259701Sdim 2124259701Sdim State.Stack.back().LastSpace = StartColumn; 2125259701Sdim } 2126321369Sdim 2127321369Sdim Token->updateNextToken(State); 2128321369Sdim 2129327952Sdim return {Penalty, Exceeded}; 2130259701Sdim} 2131259701Sdim 2132259701Sdimunsigned ContinuationIndenter::getColumnLimit(const LineState &State) const { 2133259701Sdim // In preprocessor directives reserve two chars for trailing " \" 2134259701Sdim return Style.ColumnLimit - (State.Line->InPPDirective ? 2 : 0); 2135259701Sdim} 2136259701Sdim 2137276479Sdimbool ContinuationIndenter::nextIsMultilineString(const LineState &State) { 2138259701Sdim const FormatToken &Current = *State.NextToken; 2139280031Sdim if (!Current.isStringLiteral() || Current.is(TT_ImplicitStringLiteral)) 2140259701Sdim return false; 2141259701Sdim // We never consider raw string literals "multiline" for the purpose of 2142276479Sdim // AlwaysBreakBeforeMultilineStrings implementation as they are special-cased 2143276479Sdim // (see TokenAnnotator::mustBreakBefore(). 2144259701Sdim if (Current.TokenText.startswith("R\"")) 2145259701Sdim return false; 2146259701Sdim if (Current.IsMultiline) 2147259701Sdim return true; 2148259701Sdim if (Current.getNextNonComment() && 2149276479Sdim Current.getNextNonComment()->isStringLiteral()) 2150259701Sdim return true; // Implicit concatenation. 2151341825Sdim if (Style.ColumnLimit != 0 && Style.BreakStringLiterals && 2152288943Sdim State.Column + Current.ColumnWidth + Current.UnbreakableTailLength > 2153288943Sdim Style.ColumnLimit) 2154259701Sdim return true; // String will be split. 2155259701Sdim return false; 2156259701Sdim} 2157259701Sdim 2158259701Sdim} // namespace format 2159259701Sdim} // namespace clang 2160