1259701Sdim//===--- ContinuationIndenter.cpp - Format C++ code -----------------------===// 2259701Sdim// 3353358Sdim// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4353358Sdim// See https://llvm.org/LICENSE.txt for license information. 5353358Sdim// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6259701Sdim// 7259701Sdim//===----------------------------------------------------------------------===// 8259701Sdim/// 9259701Sdim/// \file 10341825Sdim/// This file implements the continuation indenter. 11259701Sdim/// 12259701Sdim//===----------------------------------------------------------------------===// 13259701Sdim 14327952Sdim#include "ContinuationIndenter.h" 15259701Sdim#include "BreakableToken.h" 16327952Sdim#include "FormatInternal.h" 17259701Sdim#include "WhitespaceManager.h" 18259701Sdim#include "clang/Basic/OperatorPrecedence.h" 19259701Sdim#include "clang/Basic/SourceManager.h" 20259701Sdim#include "clang/Format/Format.h" 21259701Sdim#include "llvm/Support/Debug.h" 22259701Sdim 23321369Sdim#define DEBUG_TYPE "format-indenter" 24276479Sdim 25259701Sdimnamespace clang { 26259701Sdimnamespace format { 27259701Sdim 28341825Sdim// Returns true if a TT_SelectorName should be indented when wrapped, 29341825Sdim// false otherwise. 30341825Sdimstatic bool shouldIndentWrappedSelectorName(const FormatStyle &Style, 31341825Sdim LineType LineType) { 32341825Sdim return Style.IndentWrappedFunctionNames || LineType == LT_ObjCMethodDecl; 33341825Sdim} 34341825Sdim 35259701Sdim// Returns the length of everything up to the first possible line break after 36259701Sdim// the ), ], } or > matching \c Tok. 37341825Sdimstatic unsigned getLengthToMatchingParen(const FormatToken &Tok, 38341825Sdim const std::vector<ParenState> &Stack) { 39341825Sdim // Normally whether or not a break before T is possible is calculated and 40341825Sdim // stored in T.CanBreakBefore. Braces, array initializers and text proto 41341825Sdim // messages like `key: < ... >` are an exception: a break is possible 42341825Sdim // before a closing brace R if a break was inserted after the corresponding 43341825Sdim // opening brace. The information about whether or not a break is needed 44341825Sdim // before a closing brace R is stored in the ParenState field 45341825Sdim // S.BreakBeforeClosingBrace where S is the state that R closes. 46341825Sdim // 47341825Sdim // In order to decide whether there can be a break before encountered right 48341825Sdim // braces, this implementation iterates over the sequence of tokens and over 49341825Sdim // the paren stack in lockstep, keeping track of the stack level which visited 50341825Sdim // right braces correspond to in MatchingStackIndex. 51341825Sdim // 52341825Sdim // For example, consider: 53341825Sdim // L. <- line number 54341825Sdim // 1. { 55341825Sdim // 2. {1}, 56341825Sdim // 3. {2}, 57341825Sdim // 4. {{3}}} 58341825Sdim // ^ where we call this method with this token. 59341825Sdim // The paren stack at this point contains 3 brace levels: 60341825Sdim // 0. { at line 1, BreakBeforeClosingBrace: true 61341825Sdim // 1. first { at line 4, BreakBeforeClosingBrace: false 62341825Sdim // 2. second { at line 4, BreakBeforeClosingBrace: false, 63341825Sdim // where there might be fake parens levels in-between these levels. 64341825Sdim // The algorithm will start at the first } on line 4, which is the matching 65341825Sdim // brace of the initial left brace and at level 2 of the stack. Then, 66341825Sdim // examining BreakBeforeClosingBrace: false at level 2, it will continue to 67341825Sdim // the second } on line 4, and will traverse the stack downwards until it 68341825Sdim // finds the matching { on level 1. Then, examining BreakBeforeClosingBrace: 69341825Sdim // false at level 1, it will continue to the third } on line 4 and will 70341825Sdim // traverse the stack downwards until it finds the matching { on level 0. 71341825Sdim // Then, examining BreakBeforeClosingBrace: true at level 0, the algorithm 72341825Sdim // will stop and will use the second } on line 4 to determine the length to 73341825Sdim // return, as in this example the range will include the tokens: {3}} 74341825Sdim // 75341825Sdim // The algorithm will only traverse the stack if it encounters braces, array 76341825Sdim // initializer squares or text proto angle brackets. 77276479Sdim if (!Tok.MatchingParen) 78259701Sdim return 0; 79259701Sdim FormatToken *End = Tok.MatchingParen; 80341825Sdim // Maintains a stack level corresponding to the current End token. 81341825Sdim int MatchingStackIndex = Stack.size() - 1; 82341825Sdim // Traverses the stack downwards, looking for the level to which LBrace 83341825Sdim // corresponds. Returns either a pointer to the matching level or nullptr if 84341825Sdim // LParen is not found in the initial portion of the stack up to 85341825Sdim // MatchingStackIndex. 86341825Sdim auto FindParenState = [&](const FormatToken *LBrace) -> const ParenState * { 87341825Sdim while (MatchingStackIndex >= 0 && Stack[MatchingStackIndex].Tok != LBrace) 88341825Sdim --MatchingStackIndex; 89341825Sdim return MatchingStackIndex >= 0 ? &Stack[MatchingStackIndex] : nullptr; 90341825Sdim }; 91341825Sdim for (; End->Next; End = End->Next) { 92341825Sdim if (End->Next->CanBreakBefore) 93341825Sdim break; 94341825Sdim if (!End->Next->closesScope()) 95341825Sdim continue; 96341825Sdim if (End->Next->MatchingParen && 97341825Sdim End->Next->MatchingParen->isOneOf( 98341825Sdim tok::l_brace, TT_ArrayInitializerLSquare, tok::less)) { 99341825Sdim const ParenState *State = FindParenState(End->Next->MatchingParen); 100341825Sdim if (State && State->BreakBeforeClosingBrace) 101341825Sdim break; 102341825Sdim } 103259701Sdim } 104259701Sdim return End->TotalLength - Tok.TotalLength + 1; 105259701Sdim} 106259701Sdim 107296417Sdimstatic unsigned getLengthToNextOperator(const FormatToken &Tok) { 108296417Sdim if (!Tok.NextOperator) 109296417Sdim return 0; 110296417Sdim return Tok.NextOperator->TotalLength - Tok.TotalLength; 111296417Sdim} 112296417Sdim 113259701Sdim// Returns \c true if \c Tok is the "." or "->" of a call and starts the next 114259701Sdim// segment of a builder type call. 115259701Sdimstatic bool startsSegmentOfBuilderTypeCall(const FormatToken &Tok) { 116259701Sdim return Tok.isMemberAccess() && Tok.Previous && Tok.Previous->closesScope(); 117259701Sdim} 118259701Sdim 119259701Sdim// Returns \c true if \c Current starts a new parameter. 120259701Sdimstatic bool startsNextParameter(const FormatToken &Current, 121259701Sdim const FormatStyle &Style) { 122259701Sdim const FormatToken &Previous = *Current.Previous; 123280031Sdim if (Current.is(TT_CtorInitializerComma) && 124321369Sdim Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma) 125259701Sdim return true; 126321369Sdim if (Style.Language == FormatStyle::LK_Proto && Current.is(TT_SelectorName)) 127321369Sdim return true; 128259701Sdim return Previous.is(tok::comma) && !Current.isTrailingComment() && 129321369Sdim ((Previous.isNot(TT_CtorInitializerComma) || 130321369Sdim Style.BreakConstructorInitializers != 131321369Sdim FormatStyle::BCIS_BeforeComma) && 132321369Sdim (Previous.isNot(TT_InheritanceComma) || 133341825Sdim Style.BreakInheritanceList != FormatStyle::BILS_BeforeComma)); 134259701Sdim} 135259701Sdim 136321369Sdimstatic bool opensProtoMessageField(const FormatToken &LessTok, 137321369Sdim const FormatStyle &Style) { 138321369Sdim if (LessTok.isNot(tok::less)) 139321369Sdim return false; 140321369Sdim return Style.Language == FormatStyle::LK_TextProto || 141321369Sdim (Style.Language == FormatStyle::LK_Proto && 142321369Sdim (LessTok.NestingLevel > 0 || 143321369Sdim (LessTok.Previous && LessTok.Previous->is(tok::equal)))); 144321369Sdim} 145321369Sdim 146327952Sdim// Returns the delimiter of a raw string literal, or None if TokenText is not 147327952Sdim// the text of a raw string literal. The delimiter could be the empty string. 148327952Sdim// For example, the delimiter of R"deli(cont)deli" is deli. 149327952Sdimstatic llvm::Optional<StringRef> getRawStringDelimiter(StringRef TokenText) { 150327952Sdim if (TokenText.size() < 5 // The smallest raw string possible is 'R"()"'. 151327952Sdim || !TokenText.startswith("R\"") || !TokenText.endswith("\"")) 152327952Sdim return None; 153327952Sdim 154327952Sdim // A raw string starts with 'R"<delimiter>(' and delimiter is ascii and has 155327952Sdim // size at most 16 by the standard, so the first '(' must be among the first 156327952Sdim // 19 bytes. 157327952Sdim size_t LParenPos = TokenText.substr(0, 19).find_first_of('('); 158327952Sdim if (LParenPos == StringRef::npos) 159327952Sdim return None; 160327952Sdim StringRef Delimiter = TokenText.substr(2, LParenPos - 2); 161327952Sdim 162327952Sdim // Check that the string ends in ')Delimiter"'. 163327952Sdim size_t RParenPos = TokenText.size() - Delimiter.size() - 2; 164327952Sdim if (TokenText[RParenPos] != ')') 165327952Sdim return None; 166327952Sdim if (!TokenText.substr(RParenPos + 1).startswith(Delimiter)) 167327952Sdim return None; 168327952Sdim return Delimiter; 169327952Sdim} 170327952Sdim 171341825Sdim// Returns the canonical delimiter for \p Language, or the empty string if no 172341825Sdim// canonical delimiter is specified. 173341825Sdimstatic StringRef 174341825SdimgetCanonicalRawStringDelimiter(const FormatStyle &Style, 175341825Sdim FormatStyle::LanguageKind Language) { 176341825Sdim for (const auto &Format : Style.RawStringFormats) { 177341825Sdim if (Format.Language == Language) 178341825Sdim return StringRef(Format.CanonicalDelimiter); 179341825Sdim } 180341825Sdim return ""; 181341825Sdim} 182341825Sdim 183327952SdimRawStringFormatStyleManager::RawStringFormatStyleManager( 184327952Sdim const FormatStyle &CodeStyle) { 185327952Sdim for (const auto &RawStringFormat : CodeStyle.RawStringFormats) { 186341825Sdim llvm::Optional<FormatStyle> LanguageStyle = 187341825Sdim CodeStyle.GetLanguageStyle(RawStringFormat.Language); 188341825Sdim if (!LanguageStyle) { 189341825Sdim FormatStyle PredefinedStyle; 190341825Sdim if (!getPredefinedStyle(RawStringFormat.BasedOnStyle, 191341825Sdim RawStringFormat.Language, &PredefinedStyle)) { 192341825Sdim PredefinedStyle = getLLVMStyle(); 193341825Sdim PredefinedStyle.Language = RawStringFormat.Language; 194341825Sdim } 195341825Sdim LanguageStyle = PredefinedStyle; 196327952Sdim } 197341825Sdim LanguageStyle->ColumnLimit = CodeStyle.ColumnLimit; 198341825Sdim for (StringRef Delimiter : RawStringFormat.Delimiters) { 199341825Sdim DelimiterStyle.insert({Delimiter, *LanguageStyle}); 200341825Sdim } 201341825Sdim for (StringRef EnclosingFunction : RawStringFormat.EnclosingFunctions) { 202341825Sdim EnclosingFunctionStyle.insert({EnclosingFunction, *LanguageStyle}); 203341825Sdim } 204327952Sdim } 205327952Sdim} 206327952Sdim 207327952Sdimllvm::Optional<FormatStyle> 208341825SdimRawStringFormatStyleManager::getDelimiterStyle(StringRef Delimiter) const { 209327952Sdim auto It = DelimiterStyle.find(Delimiter); 210327952Sdim if (It == DelimiterStyle.end()) 211327952Sdim return None; 212327952Sdim return It->second; 213327952Sdim} 214327952Sdim 215341825Sdimllvm::Optional<FormatStyle> 216341825SdimRawStringFormatStyleManager::getEnclosingFunctionStyle( 217341825Sdim StringRef EnclosingFunction) const { 218341825Sdim auto It = EnclosingFunctionStyle.find(EnclosingFunction); 219341825Sdim if (It == EnclosingFunctionStyle.end()) 220341825Sdim return None; 221341825Sdim return It->second; 222341825Sdim} 223341825Sdim 224259701SdimContinuationIndenter::ContinuationIndenter(const FormatStyle &Style, 225280031Sdim const AdditionalKeywords &Keywords, 226309124Sdim const SourceManager &SourceMgr, 227259701Sdim WhitespaceManager &Whitespaces, 228259701Sdim encoding::Encoding Encoding, 229259701Sdim bool BinPackInconclusiveFunctions) 230280031Sdim : Style(Style), Keywords(Keywords), SourceMgr(SourceMgr), 231280031Sdim Whitespaces(Whitespaces), Encoding(Encoding), 232276479Sdim BinPackInconclusiveFunctions(BinPackInconclusiveFunctions), 233327952Sdim CommentPragmasRegex(Style.CommentPragmas), RawStringFormats(Style) {} 234259701Sdim 235259701SdimLineState ContinuationIndenter::getInitialState(unsigned FirstIndent, 236327952Sdim unsigned FirstStartColumn, 237259701Sdim const AnnotatedLine *Line, 238259701Sdim bool DryRun) { 239259701Sdim LineState State; 240259701Sdim State.FirstIndent = FirstIndent; 241327952Sdim if (FirstStartColumn && Line->First->NewlinesBefore == 0) 242327952Sdim State.Column = FirstStartColumn; 243327952Sdim else 244327952Sdim State.Column = FirstIndent; 245327952Sdim // With preprocessor directive indentation, the line starts on column 0 246327952Sdim // since it's indented after the hash, but FirstIndent is set to the 247327952Sdim // preprocessor indent. 248327952Sdim if (Style.IndentPPDirectives == FormatStyle::PPDIS_AfterHash && 249327952Sdim (Line->Type == LT_PreprocessorDirective || 250327952Sdim Line->Type == LT_ImportStatement)) 251327952Sdim State.Column = 0; 252259701Sdim State.Line = Line; 253259701Sdim State.NextToken = Line->First; 254341825Sdim State.Stack.push_back(ParenState(/*Tok=*/nullptr, FirstIndent, FirstIndent, 255259701Sdim /*AvoidBinPacking=*/false, 256259701Sdim /*NoLineBreak=*/false)); 257259701Sdim State.LineContainsContinuedForLoopSection = false; 258327952Sdim State.NoContinuation = false; 259259701Sdim State.StartOfStringLiteral = 0; 260276479Sdim State.StartOfLineLevel = 0; 261276479Sdim State.LowestLevelOnLine = 0; 262259701Sdim State.IgnoreStackForComparison = false; 263259701Sdim 264321369Sdim if (Style.Language == FormatStyle::LK_TextProto) { 265321369Sdim // We need this in order to deal with the bin packing of text fields at 266321369Sdim // global scope. 267321369Sdim State.Stack.back().AvoidBinPacking = true; 268321369Sdim State.Stack.back().BreakBeforeParameter = true; 269341825Sdim State.Stack.back().AlignColons = false; 270321369Sdim } 271321369Sdim 272259701Sdim // The first token has already been indented and thus consumed. 273259701Sdim moveStateToNextToken(State, DryRun, /*Newline=*/false); 274259701Sdim return State; 275259701Sdim} 276259701Sdim 277259701Sdimbool ContinuationIndenter::canBreak(const LineState &State) { 278259701Sdim const FormatToken &Current = *State.NextToken; 279259701Sdim const FormatToken &Previous = *Current.Previous; 280259701Sdim assert(&Previous == Current.Previous); 281327952Sdim if (!Current.CanBreakBefore && !(State.Stack.back().BreakBeforeClosingBrace && 282327952Sdim Current.closesBlockOrBlockTypeList(Style))) 283259701Sdim return false; 284259701Sdim // The opening "{" of a braced list has to be on the same line as the first 285259701Sdim // element if it is nested in another braced init list or function call. 286259701Sdim if (!Current.MustBreakBefore && Previous.is(tok::l_brace) && 287280031Sdim Previous.isNot(TT_DictLiteral) && Previous.BlockKind == BK_BracedInit && 288276479Sdim Previous.Previous && 289259701Sdim Previous.Previous->isOneOf(tok::l_brace, tok::l_paren, tok::comma)) 290259701Sdim return false; 291259701Sdim // This prevents breaks like: 292259701Sdim // ... 293259701Sdim // SomeParameter, OtherParameter).DoSomething( 294259701Sdim // ... 295259701Sdim // As they hide "DoSomething" and are generally bad for readability. 296276479Sdim if (Previous.opensScope() && Previous.isNot(tok::l_brace) && 297276479Sdim State.LowestLevelOnLine < State.StartOfLineLevel && 298276479Sdim State.LowestLevelOnLine < Current.NestingLevel) 299259701Sdim return false; 300259701Sdim if (Current.isMemberAccess() && State.Stack.back().ContainsUnwrappedBuilder) 301259701Sdim return false; 302276479Sdim 303276479Sdim // Don't create a 'hanging' indent if there are multiple blocks in a single 304276479Sdim // statement. 305280031Sdim if (Previous.is(tok::l_brace) && State.Stack.size() > 1 && 306280031Sdim State.Stack[State.Stack.size() - 2].NestedBlockInlined && 307276479Sdim State.Stack[State.Stack.size() - 2].HasMultipleNestedBlocks) 308276479Sdim return false; 309276479Sdim 310280031Sdim // Don't break after very short return types (e.g. "void") as that is often 311280031Sdim // unexpected. 312296417Sdim if (Current.is(TT_FunctionDeclarationName) && State.Column < 6) { 313296417Sdim if (Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None) 314296417Sdim return false; 315296417Sdim } 316280031Sdim 317321369Sdim // If binary operators are moved to the next line (including commas for some 318321369Sdim // styles of constructor initializers), that's always ok. 319321369Sdim if (!Current.isOneOf(TT_BinaryOperator, tok::comma) && 320321369Sdim State.Stack.back().NoLineBreakInOperand) 321321369Sdim return false; 322321369Sdim 323341825Sdim if (Previous.is(tok::l_square) && Previous.is(TT_ObjCMethodExpr)) 324341825Sdim return false; 325341825Sdim 326259701Sdim return !State.Stack.back().NoLineBreak; 327259701Sdim} 328259701Sdim 329259701Sdimbool ContinuationIndenter::mustBreak(const LineState &State) { 330259701Sdim const FormatToken &Current = *State.NextToken; 331259701Sdim const FormatToken &Previous = *Current.Previous; 332280031Sdim if (Current.MustBreakBefore || Current.is(TT_InlineASMColon)) 333259701Sdim return true; 334259701Sdim if (State.Stack.back().BreakBeforeClosingBrace && 335296417Sdim Current.closesBlockOrBlockTypeList(Style)) 336259701Sdim return true; 337259701Sdim if (Previous.is(tok::semi) && State.LineContainsContinuedForLoopSection) 338259701Sdim return true; 339341825Sdim if (Style.Language == FormatStyle::LK_ObjC && 340341825Sdim Current.ObjCSelectorNameParts > 1 && 341341825Sdim Current.startsSequence(TT_SelectorName, tok::colon, tok::caret)) { 342341825Sdim return true; 343341825Sdim } 344259701Sdim if ((startsNextParameter(Current, Style) || Previous.is(tok::semi) || 345296417Sdim (Previous.is(TT_TemplateCloser) && Current.is(TT_StartOfName) && 346321369Sdim Style.isCpp() && 347296417Sdim // FIXME: This is a temporary workaround for the case where clang-format 348296417Sdim // sets BreakBeforeParameter to avoid bin packing and this creates a 349296417Sdim // completely unnecessary line break after a template type that isn't 350296417Sdim // line-wrapped. 351296417Sdim (Previous.NestingLevel == 1 || Style.BinPackParameters)) || 352288943Sdim (Style.BreakBeforeTernaryOperators && Current.is(TT_ConditionalExpr) && 353288943Sdim Previous.isNot(tok::question)) || 354259701Sdim (!Style.BreakBeforeTernaryOperators && 355288943Sdim Previous.is(TT_ConditionalExpr))) && 356259701Sdim State.Stack.back().BreakBeforeParameter && !Current.isTrailingComment() && 357259701Sdim !Current.isOneOf(tok::r_paren, tok::r_brace)) 358259701Sdim return true; 359280031Sdim if (((Previous.is(TT_DictLiteral) && Previous.is(tok::l_brace)) || 360296417Sdim (Previous.is(TT_ArrayInitializerLSquare) && 361321369Sdim Previous.ParameterCount > 1) || 362321369Sdim opensProtoMessageField(Previous, Style)) && 363276479Sdim Style.ColumnLimit > 0 && 364341825Sdim getLengthToMatchingParen(Previous, State.Stack) + State.Column - 1 > 365288943Sdim getColumnLimit(State)) 366259701Sdim return true; 367321369Sdim 368321369Sdim const FormatToken &BreakConstructorInitializersToken = 369321369Sdim Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon 370321369Sdim ? Previous 371321369Sdim : Current; 372321369Sdim if (BreakConstructorInitializersToken.is(TT_CtorInitializerColon) && 373321369Sdim (State.Column + State.Line->Last->TotalLength - Previous.TotalLength > 374296417Sdim getColumnLimit(State) || 375296417Sdim State.Stack.back().BreakBeforeParameter) && 376321369Sdim (Style.AllowShortFunctionsOnASingleLine != FormatStyle::SFS_All || 377321369Sdim Style.BreakConstructorInitializers != FormatStyle::BCIS_BeforeColon || 378321369Sdim Style.ColumnLimit != 0)) 379276479Sdim return true; 380321369Sdim 381314564Sdim if (Current.is(TT_ObjCMethodExpr) && !Previous.is(TT_SelectorName) && 382314564Sdim State.Line->startsWith(TT_ObjCMethodSpecifier)) 383314564Sdim return true; 384341825Sdim if (Current.is(TT_SelectorName) && !Previous.is(tok::at) && 385341825Sdim State.Stack.back().ObjCSelectorNameFound && 386288943Sdim State.Stack.back().BreakBeforeParameter) 387288943Sdim return true; 388259701Sdim 389288943Sdim unsigned NewLineColumn = getNewLineColumn(State); 390296417Sdim if (Current.isMemberAccess() && Style.ColumnLimit != 0 && 391296417Sdim State.Column + getLengthToNextOperator(Current) > Style.ColumnLimit && 392296417Sdim (State.Column > NewLineColumn || 393296417Sdim Current.NestingLevel < State.StartOfLineLevel)) 394296417Sdim return true; 395296417Sdim 396321369Sdim if (startsSegmentOfBuilderTypeCall(Current) && 397321369Sdim (State.Stack.back().CallContinuation != 0 || 398321369Sdim State.Stack.back().BreakBeforeParameter) && 399321369Sdim // JavaScript is treated different here as there is a frequent pattern: 400321369Sdim // SomeFunction(function() { 401321369Sdim // ... 402321369Sdim // }.bind(...)); 403321369Sdim // FIXME: We should find a more generic solution to this problem. 404321369Sdim !(State.Column <= NewLineColumn && 405344779Sdim Style.Language == FormatStyle::LK_JavaScript) && 406353358Sdim !(Previous.closesScopeAfterBlock() && State.Column <= NewLineColumn)) 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) && 421353358Sdim !Previous.isOneOf(tok::kw_return, tok::lessless, tok::at, 422353358Sdim Keywords.kw_dollar) && 423288943Sdim !Previous.isOneOf(TT_InlineASMColon, TT_ConditionalExpr) && 424288943Sdim nextIsMultilineString(State)) 425288943Sdim return true; 426288943Sdim 427288943Sdim // Using CanBreakBefore here and below takes care of the decision whether the 428288943Sdim // current style uses wrapping before or after operators for the given 429288943Sdim // operator. 430288943Sdim if (Previous.is(TT_BinaryOperator) && Current.CanBreakBefore) { 431259701Sdim // If we need to break somewhere inside the LHS of a binary expression, we 432259701Sdim // should also break after the operator. Otherwise, the formatting would 433259701Sdim // hide the operator precedence, e.g. in: 434259701Sdim // if (aaaaaaaaaaaaaa == 435259701Sdim // bbbbbbbbbbbbbb && c) {.. 436259701Sdim // For comparisons, we only apply this rule, if the LHS is a binary 437259701Sdim // expression itself as otherwise, the line breaks seem superfluous. 438259701Sdim // We need special cases for ">>" which we have split into two ">" while 439259701Sdim // lexing in order to make template parsing easier. 440259701Sdim bool IsComparison = (Previous.getPrecedence() == prec::Relational || 441327952Sdim Previous.getPrecedence() == prec::Equality || 442327952Sdim Previous.getPrecedence() == prec::Spaceship) && 443259701Sdim Previous.Previous && 444280031Sdim Previous.Previous->isNot(TT_BinaryOperator); // For >>. 445259701Sdim bool LHSIsBinaryExpr = 446259701Sdim Previous.Previous && Previous.Previous->EndsBinaryExpression; 447288943Sdim if ((!IsComparison || LHSIsBinaryExpr) && !Current.isTrailingComment() && 448259701Sdim Previous.getPrecedence() != prec::Assignment && 449259701Sdim State.Stack.back().BreakBeforeParameter) 450259701Sdim return true; 451288943Sdim } else if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore && 452288943Sdim State.Stack.back().BreakBeforeParameter) { 453288943Sdim return true; 454259701Sdim } 455259701Sdim 456259701Sdim // Same as above, but for the first "<<" operator. 457280031Sdim if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator) && 458276479Sdim State.Stack.back().BreakBeforeParameter && 459259701Sdim State.Stack.back().FirstLessLess == 0) 460259701Sdim return true; 461259701Sdim 462280031Sdim if (Current.NestingLevel == 0 && !Current.isTrailingComment()) { 463288943Sdim // Always break after "template <...>" and leading annotations. This is only 464288943Sdim // for cases where the entire line does not fit on a single line as a 465288943Sdim // different LineFormatter would be used otherwise. 466280031Sdim if (Previous.ClosesTemplateDeclaration) 467341825Sdim return Style.AlwaysBreakTemplateDeclarations != FormatStyle::BTDS_No; 468288943Sdim if (Previous.is(TT_FunctionAnnotationRParen)) 469288943Sdim return true; 470280031Sdim if (Previous.is(TT_LeadingJavaAnnotation) && Current.isNot(tok::l_paren) && 471280031Sdim Current.isNot(TT_LeadingJavaAnnotation)) 472280031Sdim return true; 473280031Sdim } 474259701Sdim 475276479Sdim // If the return type spans multiple lines, wrap before the function name. 476360784Sdim if (((Current.is(TT_FunctionDeclarationName) && 477360784Sdim // Don't break before a C# function when no break after return type 478360784Sdim (!Style.isCSharp() || 479360784Sdim Style.AlwaysBreakAfterReturnType != FormatStyle::RTBS_None)) || 480296417Sdim (Current.is(tok::kw_operator) && !Previous.is(tok::coloncolon))) && 481309124Sdim !Previous.is(tok::kw_template) && State.Stack.back().BreakBeforeParameter) 482259701Sdim return true; 483276479Sdim 484276479Sdim // The following could be precomputed as they do not depend on the state. 485276479Sdim // However, as they should take effect only if the UnwrappedLine does not fit 486276479Sdim // into the ColumnLimit, they are checked here in the ContinuationIndenter. 487276479Sdim if (Style.ColumnLimit != 0 && Previous.BlockKind == BK_Block && 488276479Sdim Previous.is(tok::l_brace) && !Current.isOneOf(tok::r_brace, tok::comment)) 489276479Sdim return true; 490276479Sdim 491296417Sdim if (Current.is(tok::lessless) && 492296417Sdim ((Previous.is(tok::identifier) && Previous.TokenText == "endl") || 493296417Sdim (Previous.Tok.isLiteral() && (Previous.TokenText.endswith("\\n\"") || 494296417Sdim Previous.TokenText == "\'\\n\'")))) 495288943Sdim return true; 496288943Sdim 497327952Sdim if (Previous.is(TT_BlockComment) && Previous.IsMultiline) 498327952Sdim return true; 499327952Sdim 500327952Sdim if (State.NoContinuation) 501327952Sdim return true; 502327952Sdim 503259701Sdim return false; 504259701Sdim} 505259701Sdim 506259701Sdimunsigned ContinuationIndenter::addTokenToState(LineState &State, bool Newline, 507259701Sdim bool DryRun, 508259701Sdim unsigned ExtraSpaces) { 509259701Sdim const FormatToken &Current = *State.NextToken; 510259701Sdim 511276479Sdim assert(!State.Stack.empty()); 512327952Sdim State.NoContinuation = false; 513327952Sdim 514280031Sdim if ((Current.is(TT_ImplicitStringLiteral) && 515276479Sdim (Current.Previous->Tok.getIdentifierInfo() == nullptr || 516259701Sdim Current.Previous->Tok.getIdentifierInfo()->getPPKeywordID() == 517259701Sdim tok::pp_not_keyword))) { 518288943Sdim unsigned EndColumn = 519288943Sdim SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getEnd()); 520288943Sdim if (Current.LastNewlineOffset != 0) { 521288943Sdim // If there is a newline within this token, the final column will solely 522288943Sdim // determined by the current end column. 523288943Sdim State.Column = EndColumn; 524288943Sdim } else { 525288943Sdim unsigned StartColumn = 526288943Sdim SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getBegin()); 527288943Sdim assert(EndColumn >= StartColumn); 528288943Sdim State.Column += EndColumn - StartColumn; 529288943Sdim } 530276479Sdim moveStateToNextToken(State, DryRun, /*Newline=*/false); 531259701Sdim return 0; 532259701Sdim } 533259701Sdim 534259701Sdim unsigned Penalty = 0; 535259701Sdim if (Newline) 536259701Sdim Penalty = addTokenOnNewLine(State, DryRun); 537259701Sdim else 538259701Sdim addTokenOnCurrentLine(State, DryRun, ExtraSpaces); 539259701Sdim 540259701Sdim return moveStateToNextToken(State, DryRun, Newline) + Penalty; 541259701Sdim} 542259701Sdim 543259701Sdimvoid ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun, 544259701Sdim unsigned ExtraSpaces) { 545259701Sdim FormatToken &Current = *State.NextToken; 546259701Sdim const FormatToken &Previous = *State.NextToken->Previous; 547259701Sdim if (Current.is(tok::equal) && 548276479Sdim (State.Line->First->is(tok::kw_for) || Current.NestingLevel == 0) && 549259701Sdim State.Stack.back().VariablePos == 0) { 550259701Sdim State.Stack.back().VariablePos = State.Column; 551259701Sdim // Move over * and & if they are bound to the variable name. 552259701Sdim const FormatToken *Tok = &Previous; 553259701Sdim while (Tok && State.Stack.back().VariablePos >= Tok->ColumnWidth) { 554259701Sdim State.Stack.back().VariablePos -= Tok->ColumnWidth; 555259701Sdim if (Tok->SpacesRequiredBefore != 0) 556259701Sdim break; 557259701Sdim Tok = Tok->Previous; 558259701Sdim } 559259701Sdim if (Previous.PartOfMultiVariableDeclStmt) 560259701Sdim State.Stack.back().LastSpace = State.Stack.back().VariablePos; 561259701Sdim } 562259701Sdim 563259701Sdim unsigned Spaces = Current.SpacesRequiredBefore + ExtraSpaces; 564259701Sdim 565327952Sdim // Indent preprocessor directives after the hash if required. 566327952Sdim int PPColumnCorrection = 0; 567327952Sdim if (Style.IndentPPDirectives == FormatStyle::PPDIS_AfterHash && 568327952Sdim Previous.is(tok::hash) && State.FirstIndent > 0 && 569327952Sdim (State.Line->Type == LT_PreprocessorDirective || 570327952Sdim State.Line->Type == LT_ImportStatement)) { 571327952Sdim Spaces += State.FirstIndent; 572327952Sdim 573327952Sdim // For preprocessor indent with tabs, State.Column will be 1 because of the 574327952Sdim // hash. This causes second-level indents onward to have an extra space 575327952Sdim // after the tabs. We avoid this misalignment by subtracting 1 from the 576327952Sdim // column value passed to replaceWhitespace(). 577327952Sdim if (Style.UseTab != FormatStyle::UT_Never) 578327952Sdim PPColumnCorrection = -1; 579327952Sdim } 580327952Sdim 581259701Sdim if (!DryRun) 582321369Sdim Whitespaces.replaceWhitespace(Current, /*Newlines=*/0, Spaces, 583327952Sdim State.Column + Spaces + PPColumnCorrection); 584259701Sdim 585321369Sdim // If "BreakBeforeInheritanceComma" mode, don't break within the inheritance 586321369Sdim // declaration unless there is multiple inheritance. 587341825Sdim if (Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma && 588341825Sdim Current.is(TT_InheritanceColon)) 589321369Sdim State.Stack.back().NoLineBreak = true; 590341825Sdim if (Style.BreakInheritanceList == FormatStyle::BILS_AfterColon && 591341825Sdim Previous.is(TT_InheritanceColon)) 592341825Sdim State.Stack.back().NoLineBreak = true; 593321369Sdim 594280031Sdim if (Current.is(TT_SelectorName) && 595276479Sdim !State.Stack.back().ObjCSelectorNameFound) { 596296417Sdim unsigned MinIndent = 597296417Sdim std::max(State.FirstIndent + Style.ContinuationIndentWidth, 598296417Sdim State.Stack.back().Indent); 599296417Sdim unsigned FirstColonPos = State.Column + Spaces + Current.ColumnWidth; 600276479Sdim if (Current.LongestObjCSelectorName == 0) 601276479Sdim State.Stack.back().AlignColons = false; 602296417Sdim else if (MinIndent + Current.LongestObjCSelectorName > FirstColonPos) 603296417Sdim State.Stack.back().ColonPos = MinIndent + Current.LongestObjCSelectorName; 604259701Sdim else 605296417Sdim State.Stack.back().ColonPos = FirstColonPos; 606259701Sdim } 607259701Sdim 608296417Sdim // In "AlwaysBreak" mode, enforce wrapping directly after the parenthesis by 609296417Sdim // disallowing any further line breaks if there is no line break after the 610296417Sdim // opening parenthesis. Don't break if it doesn't conserve columns. 611296417Sdim if (Style.AlignAfterOpenBracket == FormatStyle::BAS_AlwaysBreak && 612360784Sdim (Previous.isOneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) || 613360784Sdim (Previous.is(tok::l_brace) && Previous.BlockKind != BK_Block && 614360784Sdim Style.Cpp11BracedListStyle)) && 615309124Sdim State.Column > getNewLineColumn(State) && 616327952Sdim (!Previous.Previous || !Previous.Previous->isOneOf( 617327952Sdim tok::kw_for, tok::kw_while, tok::kw_switch)) && 618309124Sdim // Don't do this for simple (no expressions) one-argument function calls 619309124Sdim // as that feels like needlessly wasting whitespace, e.g.: 620309124Sdim // 621309124Sdim // caaaaaaaaaaaall( 622309124Sdim // caaaaaaaaaaaall( 623309124Sdim // caaaaaaaaaaaall( 624309124Sdim // caaaaaaaaaaaaaaaaaaaaaaall(aaaaaaaaaaaaaa, aaaaaaaaa)))); 625309124Sdim Current.FakeLParens.size() > 0 && 626309124Sdim Current.FakeLParens.back() > prec::Unknown) 627296417Sdim State.Stack.back().NoLineBreak = true; 628321369Sdim if (Previous.is(TT_TemplateString) && Previous.opensScope()) 629321369Sdim State.Stack.back().NoLineBreak = true; 630296417Sdim 631296417Sdim if (Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign && 632296417Sdim Previous.opensScope() && Previous.isNot(TT_ObjCMethodExpr) && 633280031Sdim (Current.isNot(TT_LineComment) || Previous.BlockKind == BK_BracedInit)) 634259701Sdim State.Stack.back().Indent = State.Column + Spaces; 635259701Sdim if (State.Stack.back().AvoidBinPacking && startsNextParameter(Current, Style)) 636259701Sdim State.Stack.back().NoLineBreak = true; 637288943Sdim if (startsSegmentOfBuilderTypeCall(Current) && 638288943Sdim State.Column > getNewLineColumn(State)) 639259701Sdim State.Stack.back().ContainsUnwrappedBuilder = true; 640259701Sdim 641288943Sdim if (Current.is(TT_LambdaArrow) && Style.Language == FormatStyle::LK_Java) 642288943Sdim State.Stack.back().NoLineBreak = true; 643280031Sdim if (Current.isMemberAccess() && Previous.is(tok::r_paren) && 644280031Sdim (Previous.MatchingParen && 645321369Sdim (Previous.TotalLength - Previous.MatchingParen->TotalLength > 10))) 646280031Sdim // If there is a function call with long parameters, break before trailing 647280031Sdim // calls. This prevents things like: 648280031Sdim // EXPECT_CALL(SomeLongParameter).Times( 649280031Sdim // 2); 650280031Sdim // We don't want to do this for short parameters as they can just be 651280031Sdim // indexes. 652280031Sdim State.Stack.back().NoLineBreak = true; 653321369Sdim 654321369Sdim // Don't allow the RHS of an operator to be split over multiple lines unless 655321369Sdim // there is a line-break right after the operator. 656321369Sdim // Exclude relational operators, as there, it is always more desirable to 657321369Sdim // have the LHS 'left' of the RHS. 658321369Sdim const FormatToken *P = Current.getPreviousNonComment(); 659321369Sdim if (!Current.is(tok::comment) && P && 660321369Sdim (P->isOneOf(TT_BinaryOperator, tok::comma) || 661321369Sdim (P->is(TT_ConditionalExpr) && P->is(tok::colon))) && 662321369Sdim !P->isOneOf(TT_OverloadedOperator, TT_CtorInitializerComma) && 663321369Sdim P->getPrecedence() != prec::Assignment && 664327952Sdim P->getPrecedence() != prec::Relational && 665327952Sdim P->getPrecedence() != prec::Spaceship) { 666321369Sdim bool BreakBeforeOperator = 667321369Sdim P->MustBreakBefore || P->is(tok::lessless) || 668321369Sdim (P->is(TT_BinaryOperator) && 669321369Sdim Style.BreakBeforeBinaryOperators != FormatStyle::BOS_None) || 670321369Sdim (P->is(TT_ConditionalExpr) && Style.BreakBeforeTernaryOperators); 671321369Sdim // Don't do this if there are only two operands. In these cases, there is 672321369Sdim // always a nice vertical separation between them and the extra line break 673321369Sdim // does not help. 674321369Sdim bool HasTwoOperands = 675321369Sdim P->OperatorIndex == 0 && !P->NextOperator && !P->is(TT_ConditionalExpr); 676321369Sdim if ((!BreakBeforeOperator && !(HasTwoOperands && Style.AlignOperands)) || 677321369Sdim (!State.Stack.back().LastOperatorWrapped && BreakBeforeOperator)) 678321369Sdim State.Stack.back().NoLineBreakInOperand = true; 679280031Sdim } 680280031Sdim 681259701Sdim State.Column += Spaces; 682276479Sdim if (Current.isNot(tok::comment) && Previous.is(tok::l_paren) && 683280031Sdim Previous.Previous && 684360784Sdim (Previous.Previous->is(tok::kw_for) || Previous.Previous->isIf())) { 685259701Sdim // Treat the condition inside an if as if it was a second function 686259701Sdim // parameter, i.e. let nested calls have a continuation indent. 687259701Sdim State.Stack.back().LastSpace = State.Column; 688280031Sdim State.Stack.back().NestedBlockIndent = State.Column; 689280031Sdim } else if (!Current.isOneOf(tok::comment, tok::caret) && 690296417Sdim ((Previous.is(tok::comma) && 691296417Sdim !Previous.is(TT_OverloadedOperator)) || 692280031Sdim (Previous.is(tok::colon) && Previous.is(TT_ObjCMethodExpr)))) { 693276479Sdim State.Stack.back().LastSpace = State.Column; 694321369Sdim } else if (Previous.is(TT_CtorInitializerColon) && 695321369Sdim Style.BreakConstructorInitializers == 696321369Sdim FormatStyle::BCIS_AfterColon) { 697321369Sdim State.Stack.back().Indent = State.Column; 698321369Sdim State.Stack.back().LastSpace = State.Column; 699280031Sdim } else if ((Previous.isOneOf(TT_BinaryOperator, TT_ConditionalExpr, 700280031Sdim TT_CtorInitializerColon)) && 701280031Sdim ((Previous.getPrecedence() != prec::Assignment && 702280031Sdim (Previous.isNot(tok::lessless) || Previous.OperatorIndex != 0 || 703296417Sdim Previous.NextOperator)) || 704280031Sdim Current.StartsBinaryExpression)) { 705309124Sdim // Indent relative to the RHS of the expression unless this is a simple 706309124Sdim // assignment without binary expression on the RHS. Also indent relative to 707309124Sdim // unary operators and the colons of constructor initializers. 708344779Sdim if (Style.BreakBeforeBinaryOperators == FormatStyle::BOS_None) 709344779Sdim State.Stack.back().LastSpace = State.Column; 710280031Sdim } else if (Previous.is(TT_InheritanceColon)) { 711259701Sdim State.Stack.back().Indent = State.Column; 712259701Sdim State.Stack.back().LastSpace = State.Column; 713259701Sdim } else if (Previous.opensScope()) { 714259701Sdim // If a function has a trailing call, indent all parameters from the 715259701Sdim // opening parenthesis. This avoids confusing indents like: 716259701Sdim // OuterFunction(InnerFunctionCall( // break 717259701Sdim // ParameterToInnerFunction)) // break 718259701Sdim // .SecondInnerFunctionCall(); 719259701Sdim bool HasTrailingCall = false; 720259701Sdim if (Previous.MatchingParen) { 721259701Sdim const FormatToken *Next = Previous.MatchingParen->getNextNonComment(); 722259701Sdim HasTrailingCall = Next && Next->isMemberAccess(); 723259701Sdim } 724288943Sdim if (HasTrailingCall && State.Stack.size() > 1 && 725259701Sdim State.Stack[State.Stack.size() - 2].CallContinuation == 0) 726259701Sdim State.Stack.back().LastSpace = State.Column; 727259701Sdim } 728259701Sdim} 729259701Sdim 730259701Sdimunsigned ContinuationIndenter::addTokenOnNewLine(LineState &State, 731259701Sdim bool DryRun) { 732259701Sdim FormatToken &Current = *State.NextToken; 733259701Sdim const FormatToken &Previous = *State.NextToken->Previous; 734276479Sdim 735259701Sdim // Extra penalty that needs to be added because of the way certain line 736259701Sdim // breaks are chosen. 737259701Sdim unsigned Penalty = 0; 738259701Sdim 739276479Sdim const FormatToken *PreviousNonComment = Current.getPreviousNonComment(); 740276479Sdim const FormatToken *NextNonComment = Previous.getNextNonComment(); 741276479Sdim if (!NextNonComment) 742276479Sdim NextNonComment = &Current; 743276479Sdim // The first line break on any NestingLevel causes an extra penalty in order 744259701Sdim // prefer similar line breaks. 745259701Sdim if (!State.Stack.back().ContainsLineBreak) 746259701Sdim Penalty += 15; 747259701Sdim State.Stack.back().ContainsLineBreak = true; 748259701Sdim 749259701Sdim Penalty += State.NextToken->SplitPenalty; 750259701Sdim 751259701Sdim // Breaking before the first "<<" is generally not desirable if the LHS is 752314564Sdim // short. Also always add the penalty if the LHS is split over multiple lines 753276479Sdim // to avoid unnecessary line breaks that just work around this penalty. 754276479Sdim if (NextNonComment->is(tok::lessless) && 755276479Sdim State.Stack.back().FirstLessLess == 0 && 756276479Sdim (State.Column <= Style.ColumnLimit / 3 || 757276479Sdim State.Stack.back().BreakBeforeParameter)) 758259701Sdim Penalty += Style.PenaltyBreakFirstLessLess; 759259701Sdim 760276479Sdim State.Column = getNewLineColumn(State); 761288943Sdim 762288943Sdim // Indent nested blocks relative to this column, unless in a very specific 763288943Sdim // JavaScript special case where: 764288943Sdim // 765288943Sdim // var loooooong_name = 766288943Sdim // function() { 767288943Sdim // // code 768288943Sdim // } 769288943Sdim // 770309124Sdim // is common and should be formatted like a free-standing function. The same 771309124Sdim // goes for wrapping before the lambda return type arrow. 772309124Sdim if (!Current.is(TT_LambdaArrow) && 773309124Sdim (Style.Language != FormatStyle::LK_JavaScript || 774309124Sdim Current.NestingLevel != 0 || !PreviousNonComment || 775309124Sdim !PreviousNonComment->is(tok::equal) || 776309124Sdim !Current.isOneOf(Keywords.kw_async, Keywords.kw_function))) 777288943Sdim State.Stack.back().NestedBlockIndent = State.Column; 778288943Sdim 779276479Sdim if (NextNonComment->isMemberAccess()) { 780276479Sdim if (State.Stack.back().CallContinuation == 0) 781259701Sdim State.Stack.back().CallContinuation = State.Column; 782280031Sdim } else if (NextNonComment->is(TT_SelectorName)) { 783276479Sdim if (!State.Stack.back().ObjCSelectorNameFound) { 784276479Sdim if (NextNonComment->LongestObjCSelectorName == 0) { 785276479Sdim State.Stack.back().AlignColons = false; 786276479Sdim } else { 787276479Sdim State.Stack.back().ColonPos = 788341825Sdim (shouldIndentWrappedSelectorName(Style, State.Line->Type) 789288943Sdim ? std::max(State.Stack.back().Indent, 790288943Sdim State.FirstIndent + Style.ContinuationIndentWidth) 791288943Sdim : State.Stack.back().Indent) + 792341825Sdim std::max(NextNonComment->LongestObjCSelectorName, 793341825Sdim NextNonComment->ColumnWidth); 794276479Sdim } 795276479Sdim } else if (State.Stack.back().AlignColons && 796276479Sdim State.Stack.back().ColonPos <= NextNonComment->ColumnWidth) { 797276479Sdim State.Stack.back().ColonPos = State.Column + NextNonComment->ColumnWidth; 798259701Sdim } 799276479Sdim } else if (PreviousNonComment && PreviousNonComment->is(tok::colon) && 800280031Sdim PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) { 801276479Sdim // FIXME: This is hacky, find a better way. The problem is that in an ObjC 802276479Sdim // method expression, the block should be aligned to the line starting it, 803276479Sdim // e.g.: 804276479Sdim // [aaaaaaaaaaaaaaa aaaaaaaaa: \\ break for some reason 805276479Sdim // ^(int *i) { 806276479Sdim // // ... 807276479Sdim // }]; 808276479Sdim // Thus, we set LastSpace of the next higher NestingLevel, to which we move 809276479Sdim // when we consume all of the "}"'s FakeRParens at the "{". 810276479Sdim if (State.Stack.size() > 1) 811276479Sdim State.Stack[State.Stack.size() - 2].LastSpace = 812276479Sdim std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) + 813276479Sdim Style.ContinuationIndentWidth; 814259701Sdim } 815259701Sdim 816314564Sdim if ((PreviousNonComment && 817314564Sdim PreviousNonComment->isOneOf(tok::comma, tok::semi) && 818259701Sdim !State.Stack.back().AvoidBinPacking) || 819280031Sdim Previous.is(TT_BinaryOperator)) 820259701Sdim State.Stack.back().BreakBeforeParameter = false; 821341825Sdim if (PreviousNonComment && 822341825Sdim PreviousNonComment->isOneOf(TT_TemplateCloser, TT_JavaAnnotation) && 823280031Sdim Current.NestingLevel == 0) 824259701Sdim State.Stack.back().BreakBeforeParameter = false; 825276479Sdim if (NextNonComment->is(tok::question) || 826259701Sdim (PreviousNonComment && PreviousNonComment->is(tok::question))) 827259701Sdim State.Stack.back().BreakBeforeParameter = true; 828288943Sdim if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore) 829288943Sdim State.Stack.back().BreakBeforeParameter = false; 830259701Sdim 831259701Sdim if (!DryRun) { 832327952Sdim unsigned MaxEmptyLinesToKeep = Style.MaxEmptyLinesToKeep + 1; 833327952Sdim if (Current.is(tok::r_brace) && Current.MatchingParen && 834327952Sdim // Only strip trailing empty lines for l_braces that have children, i.e. 835327952Sdim // for function expressions (lambdas, arrows, etc). 836327952Sdim !Current.MatchingParen->Children.empty()) { 837327952Sdim // lambdas and arrow functions are expressions, thus their r_brace is not 838327952Sdim // on its own line, and thus not covered by UnwrappedLineFormatter's logic 839327952Sdim // about removing empty lines on closing blocks. Special case them here. 840327952Sdim MaxEmptyLinesToKeep = 1; 841327952Sdim } 842353358Sdim unsigned Newlines = 843353358Sdim std::max(1u, std::min(Current.NewlinesBefore, MaxEmptyLinesToKeep)); 844321369Sdim bool ContinuePPDirective = 845321369Sdim State.Line->InPPDirective && State.Line->Type != LT_ImportStatement; 846321369Sdim Whitespaces.replaceWhitespace(Current, Newlines, State.Column, State.Column, 847321369Sdim ContinuePPDirective); 848259701Sdim } 849259701Sdim 850259701Sdim if (!Current.isTrailingComment()) 851259701Sdim State.Stack.back().LastSpace = State.Column; 852309124Sdim if (Current.is(tok::lessless)) 853309124Sdim // If we are breaking before a "<<", we always want to indent relative to 854309124Sdim // RHS. This is necessary only for "<<", as we special-case it and don't 855309124Sdim // always indent relative to the RHS. 856309124Sdim State.Stack.back().LastSpace += 3; // 3 -> width of "<< ". 857309124Sdim 858276479Sdim State.StartOfLineLevel = Current.NestingLevel; 859276479Sdim State.LowestLevelOnLine = Current.NestingLevel; 860259701Sdim 861259701Sdim // Any break on this level means that the parent level has been broken 862259701Sdim // and we need to avoid bin packing there. 863280031Sdim bool NestedBlockSpecialCase = 864321369Sdim !Style.isCpp() && Current.is(tok::r_brace) && State.Stack.size() > 1 && 865280031Sdim State.Stack[State.Stack.size() - 2].NestedBlockInlined; 866288943Sdim if (!NestedBlockSpecialCase) 867288943Sdim for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i) 868276479Sdim State.Stack[i].BreakBeforeParameter = true; 869276479Sdim 870259701Sdim if (PreviousNonComment && 871321369Sdim !PreviousNonComment->isOneOf(tok::comma, tok::colon, tok::semi) && 872280031Sdim (PreviousNonComment->isNot(TT_TemplateCloser) || 873280031Sdim Current.NestingLevel != 0) && 874288943Sdim !PreviousNonComment->isOneOf( 875288943Sdim TT_BinaryOperator, TT_FunctionAnnotationRParen, TT_JavaAnnotation, 876288943Sdim TT_LeadingJavaAnnotation) && 877280031Sdim Current.isNot(TT_BinaryOperator) && !PreviousNonComment->opensScope()) 878259701Sdim State.Stack.back().BreakBeforeParameter = true; 879259701Sdim 880259701Sdim // If we break after { or the [ of an array initializer, we should also break 881259701Sdim // before the corresponding } or ]. 882276479Sdim if (PreviousNonComment && 883321369Sdim (PreviousNonComment->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) || 884327952Sdim opensProtoMessageField(*PreviousNonComment, Style))) 885259701Sdim State.Stack.back().BreakBeforeClosingBrace = true; 886259701Sdim 887259701Sdim if (State.Stack.back().AvoidBinPacking) { 888353358Sdim // If we are breaking after '(', '{', '<', or this is the break after a ':' 889353358Sdim // to start a member initializater list in a constructor, this should not 890353358Sdim // be considered bin packing unless the relevant AllowAll option is false or 891353358Sdim // this is a dict/object literal. 892353358Sdim bool PreviousIsBreakingCtorInitializerColon = 893353358Sdim Previous.is(TT_CtorInitializerColon) && 894353358Sdim Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon; 895353358Sdim if (!(Previous.isOneOf(tok::l_paren, tok::l_brace, TT_BinaryOperator) || 896353358Sdim PreviousIsBreakingCtorInitializerColon) || 897259701Sdim (!Style.AllowAllParametersOfDeclarationOnNextLine && 898276479Sdim State.Line->MustBeDeclaration) || 899353358Sdim (!Style.AllowAllArgumentsOnNextLine && 900353358Sdim !State.Line->MustBeDeclaration) || 901353358Sdim (!Style.AllowAllConstructorInitializersOnNextLine && 902353358Sdim PreviousIsBreakingCtorInitializerColon) || 903280031Sdim Previous.is(TT_DictLiteral)) 904259701Sdim State.Stack.back().BreakBeforeParameter = true; 905353358Sdim 906353358Sdim // If we are breaking after a ':' to start a member initializer list, 907353358Sdim // and we allow all arguments on the next line, we should not break 908353358Sdim // before the next parameter. 909353358Sdim if (PreviousIsBreakingCtorInitializerColon && 910353358Sdim Style.AllowAllConstructorInitializersOnNextLine) 911353358Sdim State.Stack.back().BreakBeforeParameter = false; 912259701Sdim } 913259701Sdim 914259701Sdim return Penalty; 915259701Sdim} 916259701Sdim 917276479Sdimunsigned ContinuationIndenter::getNewLineColumn(const LineState &State) { 918276479Sdim if (!State.NextToken || !State.NextToken->Previous) 919276479Sdim return 0; 920276479Sdim FormatToken &Current = *State.NextToken; 921280031Sdim const FormatToken &Previous = *Current.Previous; 922276479Sdim // If we are continuing an expression, we want to use the continuation indent. 923276479Sdim unsigned ContinuationIndent = 924276479Sdim std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) + 925276479Sdim Style.ContinuationIndentWidth; 926276479Sdim const FormatToken *PreviousNonComment = Current.getPreviousNonComment(); 927276479Sdim const FormatToken *NextNonComment = Previous.getNextNonComment(); 928276479Sdim if (!NextNonComment) 929276479Sdim NextNonComment = &Current; 930280031Sdim 931280031Sdim // Java specific bits. 932280031Sdim if (Style.Language == FormatStyle::LK_Java && 933280031Sdim Current.isOneOf(Keywords.kw_implements, Keywords.kw_extends)) 934280031Sdim return std::max(State.Stack.back().LastSpace, 935280031Sdim State.Stack.back().Indent + Style.ContinuationIndentWidth); 936280031Sdim 937360784Sdim if (Style.BreakBeforeBraces == FormatStyle::BS_Whitesmiths && 938360784Sdim State.Line->First->is(tok::kw_enum)) 939360784Sdim return (Style.IndentWidth * State.Line->First->IndentLevel) + 940360784Sdim Style.IndentWidth; 941360784Sdim 942276479Sdim if (NextNonComment->is(tok::l_brace) && NextNonComment->BlockKind == BK_Block) 943276479Sdim return Current.NestingLevel == 0 ? State.FirstIndent 944276479Sdim : State.Stack.back().Indent; 945321369Sdim if ((Current.isOneOf(tok::r_brace, tok::r_square) || 946321369Sdim (Current.is(tok::greater) && 947321369Sdim (Style.Language == FormatStyle::LK_Proto || 948321369Sdim Style.Language == FormatStyle::LK_TextProto))) && 949321369Sdim State.Stack.size() > 1) { 950296417Sdim if (Current.closesBlockOrBlockTypeList(Style)) 951280031Sdim return State.Stack[State.Stack.size() - 2].NestedBlockIndent; 952280031Sdim if (Current.MatchingParen && 953280031Sdim Current.MatchingParen->BlockKind == BK_BracedInit) 954276479Sdim return State.Stack[State.Stack.size() - 2].LastSpace; 955280031Sdim return State.FirstIndent; 956276479Sdim } 957353358Sdim // Indent a closing parenthesis at the previous level if followed by a semi, 958353358Sdim // const, or opening brace. This allows indentations such as: 959321369Sdim // foo( 960321369Sdim // a, 961321369Sdim // ); 962353358Sdim // int Foo::getter( 963353358Sdim // // 964353358Sdim // ) const { 965353358Sdim // return foo; 966353358Sdim // } 967321369Sdim // function foo( 968321369Sdim // a, 969321369Sdim // ) { 970321369Sdim // code(); // 971321369Sdim // } 972321369Sdim if (Current.is(tok::r_paren) && State.Stack.size() > 1 && 973353358Sdim (!Current.Next || 974353358Sdim Current.Next->isOneOf(tok::semi, tok::kw_const, tok::l_brace))) 975321369Sdim return State.Stack[State.Stack.size() - 2].LastSpace; 976321369Sdim if (NextNonComment->is(TT_TemplateString) && NextNonComment->closesScope()) 977321369Sdim return State.Stack[State.Stack.size() - 2].LastSpace; 978276479Sdim if (Current.is(tok::identifier) && Current.Next && 979327952Sdim (Current.Next->is(TT_DictLiteral) || 980327952Sdim ((Style.Language == FormatStyle::LK_Proto || 981327952Sdim Style.Language == FormatStyle::LK_TextProto) && 982341825Sdim Current.Next->isOneOf(tok::less, tok::l_brace)))) 983276479Sdim return State.Stack.back().Indent; 984288943Sdim if (NextNonComment->is(TT_ObjCStringLiteral) && 985288943Sdim State.StartOfStringLiteral != 0) 986288943Sdim return State.StartOfStringLiteral - 1; 987321369Sdim if (NextNonComment->isStringLiteral() && State.StartOfStringLiteral != 0) 988321369Sdim return State.StartOfStringLiteral; 989276479Sdim if (NextNonComment->is(tok::lessless) && 990276479Sdim State.Stack.back().FirstLessLess != 0) 991276479Sdim return State.Stack.back().FirstLessLess; 992276479Sdim if (NextNonComment->isMemberAccess()) { 993280031Sdim if (State.Stack.back().CallContinuation == 0) 994276479Sdim return ContinuationIndent; 995280031Sdim return State.Stack.back().CallContinuation; 996276479Sdim } 997276479Sdim if (State.Stack.back().QuestionColumn != 0 && 998276479Sdim ((NextNonComment->is(tok::colon) && 999280031Sdim NextNonComment->is(TT_ConditionalExpr)) || 1000280031Sdim Previous.is(TT_ConditionalExpr))) 1001276479Sdim return State.Stack.back().QuestionColumn; 1002276479Sdim if (Previous.is(tok::comma) && State.Stack.back().VariablePos != 0) 1003276479Sdim return State.Stack.back().VariablePos; 1004280031Sdim if ((PreviousNonComment && 1005280031Sdim (PreviousNonComment->ClosesTemplateDeclaration || 1006288943Sdim PreviousNonComment->isOneOf( 1007341825Sdim TT_AttributeParen, TT_AttributeSquare, TT_FunctionAnnotationRParen, 1008341825Sdim TT_JavaAnnotation, TT_LeadingJavaAnnotation))) || 1009276479Sdim (!Style.IndentWrappedFunctionNames && 1010280031Sdim NextNonComment->isOneOf(tok::kw_operator, TT_FunctionDeclarationName))) 1011276479Sdim return std::max(State.Stack.back().LastSpace, State.Stack.back().Indent); 1012280031Sdim if (NextNonComment->is(TT_SelectorName)) { 1013276479Sdim if (!State.Stack.back().ObjCSelectorNameFound) { 1014341825Sdim unsigned MinIndent = State.Stack.back().Indent; 1015341825Sdim if (shouldIndentWrappedSelectorName(Style, State.Line->Type)) 1016341825Sdim MinIndent = std::max(MinIndent, 1017341825Sdim State.FirstIndent + Style.ContinuationIndentWidth); 1018341825Sdim // If LongestObjCSelectorName is 0, we are indenting the first 1019341825Sdim // part of an ObjC selector (or a selector component which is 1020341825Sdim // not colon-aligned due to block formatting). 1021341825Sdim // 1022341825Sdim // Otherwise, we are indenting a subsequent part of an ObjC 1023341825Sdim // selector which should be colon-aligned to the longest 1024341825Sdim // component of the ObjC selector. 1025341825Sdim // 1026341825Sdim // In either case, we want to respect Style.IndentWrappedFunctionNames. 1027341825Sdim return MinIndent + 1028341825Sdim std::max(NextNonComment->LongestObjCSelectorName, 1029341825Sdim NextNonComment->ColumnWidth) - 1030280031Sdim NextNonComment->ColumnWidth; 1031280031Sdim } 1032280031Sdim if (!State.Stack.back().AlignColons) 1033276479Sdim return State.Stack.back().Indent; 1034280031Sdim if (State.Stack.back().ColonPos > NextNonComment->ColumnWidth) 1035276479Sdim return State.Stack.back().ColonPos - NextNonComment->ColumnWidth; 1036280031Sdim return State.Stack.back().Indent; 1037276479Sdim } 1038314564Sdim if (NextNonComment->is(tok::colon) && NextNonComment->is(TT_ObjCMethodExpr)) 1039314564Sdim return State.Stack.back().ColonPos; 1040280031Sdim if (NextNonComment->is(TT_ArraySubscriptLSquare)) { 1041276479Sdim if (State.Stack.back().StartOfArraySubscripts != 0) 1042276479Sdim return State.Stack.back().StartOfArraySubscripts; 1043280031Sdim return ContinuationIndent; 1044276479Sdim } 1045288943Sdim 1046288943Sdim // This ensure that we correctly format ObjC methods calls without inputs, 1047288943Sdim // i.e. where the last element isn't selector like: [callee method]; 1048288943Sdim if (NextNonComment->is(tok::identifier) && NextNonComment->FakeRParens == 0 && 1049288943Sdim NextNonComment->Next && NextNonComment->Next->is(TT_ObjCMethodExpr)) 1050288943Sdim return State.Stack.back().Indent; 1051288943Sdim 1052288943Sdim if (NextNonComment->isOneOf(TT_StartOfName, TT_PointerOrReference) || 1053288943Sdim Previous.isOneOf(tok::coloncolon, tok::equal, TT_JsTypeColon)) 1054276479Sdim return ContinuationIndent; 1055276479Sdim if (PreviousNonComment && PreviousNonComment->is(tok::colon) && 1056280031Sdim PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) 1057276479Sdim return ContinuationIndent; 1058280031Sdim if (NextNonComment->is(TT_CtorInitializerComma)) 1059276479Sdim return State.Stack.back().Indent; 1060321369Sdim if (PreviousNonComment && PreviousNonComment->is(TT_CtorInitializerColon) && 1061321369Sdim Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon) 1062321369Sdim return State.Stack.back().Indent; 1063341825Sdim if (PreviousNonComment && PreviousNonComment->is(TT_InheritanceColon) && 1064341825Sdim Style.BreakInheritanceList == FormatStyle::BILS_AfterColon) 1065341825Sdim return State.Stack.back().Indent; 1066321369Sdim if (NextNonComment->isOneOf(TT_CtorInitializerColon, TT_InheritanceColon, 1067321369Sdim TT_InheritanceComma)) 1068321369Sdim return State.FirstIndent + Style.ConstructorInitializerIndentWidth; 1069280031Sdim if (Previous.is(tok::r_paren) && !Current.isBinaryOperator() && 1070280031Sdim !Current.isOneOf(tok::colon, tok::comment)) 1071280031Sdim return ContinuationIndent; 1072341825Sdim if (Current.is(TT_ProtoExtensionLSquare)) 1073341825Sdim return State.Stack.back().Indent; 1074276479Sdim if (State.Stack.back().Indent == State.FirstIndent && PreviousNonComment && 1075353358Sdim !PreviousNonComment->isOneOf(tok::r_brace, TT_CtorInitializerComma)) 1076276479Sdim // Ensure that we fall back to the continuation indent width instead of 1077276479Sdim // just flushing continuations left. 1078276479Sdim return State.Stack.back().Indent + Style.ContinuationIndentWidth; 1079276479Sdim return State.Stack.back().Indent; 1080276479Sdim} 1081276479Sdim 1082259701Sdimunsigned ContinuationIndenter::moveStateToNextToken(LineState &State, 1083259701Sdim bool DryRun, bool Newline) { 1084276479Sdim assert(State.Stack.size()); 1085259701Sdim const FormatToken &Current = *State.NextToken; 1086259701Sdim 1087321369Sdim if (Current.isOneOf(tok::comma, TT_BinaryOperator)) 1088321369Sdim State.Stack.back().NoLineBreakInOperand = false; 1089280031Sdim if (Current.is(TT_InheritanceColon)) 1090259701Sdim State.Stack.back().AvoidBinPacking = true; 1091280031Sdim if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) { 1092276479Sdim if (State.Stack.back().FirstLessLess == 0) 1093276479Sdim State.Stack.back().FirstLessLess = State.Column; 1094276479Sdim else 1095276479Sdim State.Stack.back().LastOperatorWrapped = Newline; 1096276479Sdim } 1097321369Sdim if (Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless)) 1098276479Sdim State.Stack.back().LastOperatorWrapped = Newline; 1099321369Sdim if (Current.is(TT_ConditionalExpr) && Current.Previous && 1100321369Sdim !Current.Previous->is(TT_ConditionalExpr)) 1101321369Sdim State.Stack.back().LastOperatorWrapped = Newline; 1102280031Sdim if (Current.is(TT_ArraySubscriptLSquare) && 1103259701Sdim State.Stack.back().StartOfArraySubscripts == 0) 1104259701Sdim State.Stack.back().StartOfArraySubscripts = State.Column; 1105309124Sdim if (Style.BreakBeforeTernaryOperators && Current.is(tok::question)) 1106259701Sdim State.Stack.back().QuestionColumn = State.Column; 1107309124Sdim if (!Style.BreakBeforeTernaryOperators && Current.isNot(tok::colon)) { 1108309124Sdim const FormatToken *Previous = Current.Previous; 1109309124Sdim while (Previous && Previous->isTrailingComment()) 1110309124Sdim Previous = Previous->Previous; 1111309124Sdim if (Previous && Previous->is(tok::question)) 1112309124Sdim State.Stack.back().QuestionColumn = State.Column; 1113309124Sdim } 1114321369Sdim if (!Current.opensScope() && !Current.closesScope() && 1115321369Sdim !Current.is(TT_PointerOrReference)) 1116259701Sdim State.LowestLevelOnLine = 1117276479Sdim std::min(State.LowestLevelOnLine, Current.NestingLevel); 1118259701Sdim if (Current.isMemberAccess()) 1119259701Sdim State.Stack.back().StartOfFunctionCall = 1120296417Sdim !Current.NextOperator ? 0 : State.Column; 1121341825Sdim if (Current.is(TT_SelectorName)) 1122276479Sdim State.Stack.back().ObjCSelectorNameFound = true; 1123321369Sdim if (Current.is(TT_CtorInitializerColon) && 1124321369Sdim Style.BreakConstructorInitializers != FormatStyle::BCIS_AfterColon) { 1125259701Sdim // Indent 2 from the column, so: 1126259701Sdim // SomeClass::SomeClass() 1127259701Sdim // : First(...), ... 1128259701Sdim // Next(...) 1129259701Sdim // ^ line up here. 1130259701Sdim State.Stack.back().Indent = 1131327952Sdim State.Column + 1132327952Sdim (Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma 1133327952Sdim ? 0 1134327952Sdim : 2); 1135280031Sdim State.Stack.back().NestedBlockIndent = State.Stack.back().Indent; 1136353358Sdim if (Style.ConstructorInitializerAllOnOneLineOrOnePerLine) { 1137259701Sdim State.Stack.back().AvoidBinPacking = true; 1138353358Sdim State.Stack.back().BreakBeforeParameter = 1139353358Sdim !Style.AllowAllConstructorInitializersOnNextLine; 1140353358Sdim } else { 1141353358Sdim State.Stack.back().BreakBeforeParameter = false; 1142353358Sdim } 1143259701Sdim } 1144321369Sdim if (Current.is(TT_CtorInitializerColon) && 1145321369Sdim Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon) { 1146321369Sdim State.Stack.back().Indent = 1147321369Sdim State.FirstIndent + Style.ConstructorInitializerIndentWidth; 1148321369Sdim State.Stack.back().NestedBlockIndent = State.Stack.back().Indent; 1149321369Sdim if (Style.ConstructorInitializerAllOnOneLineOrOnePerLine) 1150327952Sdim State.Stack.back().AvoidBinPacking = true; 1151321369Sdim } 1152321369Sdim if (Current.is(TT_InheritanceColon)) 1153321369Sdim State.Stack.back().Indent = 1154341825Sdim State.FirstIndent + Style.ConstructorInitializerIndentWidth; 1155288943Sdim if (Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline) 1156288943Sdim State.Stack.back().NestedBlockIndent = 1157288943Sdim State.Column + Current.ColumnWidth + 1; 1158321369Sdim if (Current.isOneOf(TT_LambdaLSquare, TT_LambdaArrow)) 1159321369Sdim State.Stack.back().LastSpace = State.Column; 1160259701Sdim 1161259701Sdim // Insert scopes created by fake parenthesis. 1162259701Sdim const FormatToken *Previous = Current.getPreviousNonComment(); 1163276479Sdim 1164276479Sdim // Add special behavior to support a format commonly used for JavaScript 1165276479Sdim // closures: 1166276479Sdim // SomeFunction(function() { 1167276479Sdim // foo(); 1168276479Sdim // bar(); 1169276479Sdim // }, a, b, c); 1170288943Sdim if (Current.isNot(tok::comment) && Previous && 1171288943Sdim Previous->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) && 1172344779Sdim !Previous->is(TT_DictLiteral) && State.Stack.size() > 1 && 1173344779Sdim !State.Stack.back().HasMultipleNestedBlocks) { 1174288943Sdim if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline) 1175288943Sdim for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i) 1176280031Sdim State.Stack[i].NoLineBreak = true; 1177280031Sdim State.Stack[State.Stack.size() - 2].NestedBlockInlined = false; 1178276479Sdim } 1179327952Sdim if (Previous && 1180327952Sdim (Previous->isOneOf(tok::l_paren, tok::comma, tok::colon) || 1181327952Sdim Previous->isOneOf(TT_BinaryOperator, TT_ConditionalExpr)) && 1182280031Sdim !Previous->isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)) { 1183280031Sdim State.Stack.back().NestedBlockInlined = 1184280031Sdim !Newline && 1185280031Sdim (Previous->isNot(tok::l_paren) || Previous->ParameterCount > 1); 1186280031Sdim } 1187276479Sdim 1188276479Sdim moveStatePastFakeLParens(State, Newline); 1189321369Sdim moveStatePastScopeCloser(State); 1190327952Sdim bool AllowBreak = !State.Stack.back().NoLineBreak && 1191327952Sdim !State.Stack.back().NoLineBreakInOperand; 1192276479Sdim moveStatePastScopeOpener(State, Newline); 1193276479Sdim moveStatePastFakeRParens(State); 1194276479Sdim 1195288943Sdim if (Current.is(TT_ObjCStringLiteral) && State.StartOfStringLiteral == 0) 1196288943Sdim State.StartOfStringLiteral = State.Column + 1; 1197353358Sdim if (Current.is(TT_CSharpStringLiteral) && State.StartOfStringLiteral == 0) 1198353358Sdim State.StartOfStringLiteral = State.Column + 1; 1199321369Sdim else if (Current.isStringLiteral() && State.StartOfStringLiteral == 0) 1200321369Sdim State.StartOfStringLiteral = State.Column; 1201288943Sdim else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) && 1202288943Sdim !Current.isStringLiteral()) 1203276479Sdim State.StartOfStringLiteral = 0; 1204276479Sdim 1205276479Sdim State.Column += Current.ColumnWidth; 1206276479Sdim State.NextToken = State.NextToken->Next; 1207276479Sdim 1208327952Sdim unsigned Penalty = 1209353358Sdim handleEndOfLine(Current, State, DryRun, AllowBreak, Newline); 1210327952Sdim 1211276479Sdim if (Current.Role) 1212276479Sdim Current.Role->formatFromToken(State, this, DryRun); 1213276479Sdim // If the previous has a special role, let it consume tokens as appropriate. 1214276479Sdim // It is necessary to start at the previous token for the only implemented 1215276479Sdim // role (comma separated list). That way, the decision whether or not to break 1216276479Sdim // after the "{" is already done and both options are tried and evaluated. 1217276479Sdim // FIXME: This is ugly, find a better way. 1218276479Sdim if (Previous && Previous->Role) 1219276479Sdim Penalty += Previous->Role->formatAfterToken(State, this, DryRun); 1220276479Sdim 1221276479Sdim return Penalty; 1222276479Sdim} 1223276479Sdim 1224276479Sdimvoid ContinuationIndenter::moveStatePastFakeLParens(LineState &State, 1225276479Sdim bool Newline) { 1226276479Sdim const FormatToken &Current = *State.NextToken; 1227276479Sdim const FormatToken *Previous = Current.getPreviousNonComment(); 1228276479Sdim 1229259701Sdim // Don't add extra indentation for the first fake parenthesis after 1230276479Sdim // 'return', assignments or opening <({[. The indentation for these cases 1231259701Sdim // is special cased. 1232259701Sdim bool SkipFirstExtraIndent = 1233288943Sdim (Previous && (Previous->opensScope() || 1234288943Sdim Previous->isOneOf(tok::semi, tok::kw_return) || 1235280031Sdim (Previous->getPrecedence() == prec::Assignment && 1236280031Sdim Style.AlignOperands) || 1237280031Sdim Previous->is(TT_ObjCMethodExpr))); 1238259701Sdim for (SmallVectorImpl<prec::Level>::const_reverse_iterator 1239259701Sdim I = Current.FakeLParens.rbegin(), 1240259701Sdim E = Current.FakeLParens.rend(); 1241259701Sdim I != E; ++I) { 1242259701Sdim ParenState NewParenState = State.Stack.back(); 1243341825Sdim NewParenState.Tok = nullptr; 1244259701Sdim NewParenState.ContainsLineBreak = false; 1245321369Sdim NewParenState.LastOperatorWrapped = true; 1246321369Sdim NewParenState.NoLineBreak = 1247321369Sdim NewParenState.NoLineBreak || State.Stack.back().NoLineBreakInOperand; 1248259701Sdim 1249321369Sdim // Don't propagate AvoidBinPacking into subexpressions of arg/param lists. 1250321369Sdim if (*I > prec::Comma) 1251321369Sdim NewParenState.AvoidBinPacking = false; 1252321369Sdim 1253280031Sdim // Indent from 'LastSpace' unless these are fake parentheses encapsulating 1254280031Sdim // a builder type call after 'return' or, if the alignment after opening 1255280031Sdim // brackets is disabled. 1256280031Sdim if (!Current.isTrailingComment() && 1257280031Sdim (Style.AlignOperands || *I < prec::Assignment) && 1258280031Sdim (!Previous || Previous->isNot(tok::kw_return) || 1259280031Sdim (Style.Language != FormatStyle::LK_Java && *I > 0)) && 1260296417Sdim (Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign || 1261296417Sdim *I != prec::Comma || Current.NestingLevel == 0)) 1262259701Sdim NewParenState.Indent = 1263259701Sdim std::max(std::max(State.Column, NewParenState.Indent), 1264259701Sdim State.Stack.back().LastSpace); 1265259701Sdim 1266259701Sdim // Do not indent relative to the fake parentheses inserted for "." or "->". 1267259701Sdim // This is a special case to make the following to statements consistent: 1268259701Sdim // OuterFunction(InnerFunctionCall( // break 1269259701Sdim // ParameterToInnerFunction)); 1270259701Sdim // OuterFunction(SomeObject.InnerFunctionCall( // break 1271259701Sdim // ParameterToInnerFunction)); 1272259701Sdim if (*I > prec::Unknown) 1273259701Sdim NewParenState.LastSpace = std::max(NewParenState.LastSpace, State.Column); 1274309124Sdim if (*I != prec::Conditional && !Current.is(TT_UnaryOperator) && 1275309124Sdim Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign) 1276280031Sdim NewParenState.StartOfFunctionCall = State.Column; 1277259701Sdim 1278259701Sdim // Always indent conditional expressions. Never indent expression where 1279259701Sdim // the 'operator' is ',', ';' or an assignment (i.e. *I <= 1280259701Sdim // prec::Assignment) as those have different indentation rules. Indent 1281259701Sdim // other expression, unless the indentation needs to be skipped. 1282259701Sdim if (*I == prec::Conditional || 1283259701Sdim (!SkipFirstExtraIndent && *I > prec::Assignment && 1284280031Sdim !Current.isTrailingComment())) 1285259701Sdim NewParenState.Indent += Style.ContinuationIndentWidth; 1286296417Sdim if ((Previous && !Previous->opensScope()) || *I != prec::Comma) 1287259701Sdim NewParenState.BreakBeforeParameter = false; 1288259701Sdim State.Stack.push_back(NewParenState); 1289259701Sdim SkipFirstExtraIndent = false; 1290259701Sdim } 1291276479Sdim} 1292259701Sdim 1293280031Sdimvoid ContinuationIndenter::moveStatePastFakeRParens(LineState &State) { 1294280031Sdim for (unsigned i = 0, e = State.NextToken->FakeRParens; i != e; ++i) { 1295276479Sdim unsigned VariablePos = State.Stack.back().VariablePos; 1296276479Sdim if (State.Stack.size() == 1) { 1297276479Sdim // Do not pop the last element. 1298276479Sdim break; 1299259701Sdim } 1300276479Sdim State.Stack.pop_back(); 1301276479Sdim State.Stack.back().VariablePos = VariablePos; 1302276479Sdim } 1303276479Sdim} 1304259701Sdim 1305276479Sdimvoid ContinuationIndenter::moveStatePastScopeOpener(LineState &State, 1306276479Sdim bool Newline) { 1307276479Sdim const FormatToken &Current = *State.NextToken; 1308276479Sdim if (!Current.opensScope()) 1309276479Sdim return; 1310276479Sdim 1311276479Sdim if (Current.MatchingParen && Current.BlockKind == BK_Block) { 1312276479Sdim moveStateToNewBlock(State); 1313276479Sdim return; 1314259701Sdim } 1315259701Sdim 1316276479Sdim unsigned NewIndent; 1317288943Sdim unsigned LastSpace = State.Stack.back().LastSpace; 1318276479Sdim bool AvoidBinPacking; 1319276479Sdim bool BreakBeforeParameter = false; 1320288943Sdim unsigned NestedBlockIndent = std::max(State.Stack.back().StartOfFunctionCall, 1321288943Sdim State.Stack.back().NestedBlockIndent); 1322321369Sdim if (Current.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) || 1323321369Sdim opensProtoMessageField(Current, Style)) { 1324296417Sdim if (Current.opensBlockOrBlockTypeList(Style)) { 1325321369Sdim NewIndent = Style.IndentWidth + 1326321369Sdim std::min(State.Column, State.Stack.back().NestedBlockIndent); 1327276479Sdim } else { 1328280031Sdim NewIndent = State.Stack.back().LastSpace + Style.ContinuationIndentWidth; 1329276479Sdim } 1330276479Sdim const FormatToken *NextNoComment = Current.getNextNonComment(); 1331296417Sdim bool EndsInComma = Current.MatchingParen && 1332296417Sdim Current.MatchingParen->Previous && 1333296417Sdim Current.MatchingParen->Previous->is(tok::comma); 1334327952Sdim AvoidBinPacking = EndsInComma || Current.is(TT_DictLiteral) || 1335327952Sdim Style.Language == FormatStyle::LK_Proto || 1336327952Sdim Style.Language == FormatStyle::LK_TextProto || 1337327952Sdim !Style.BinPackArguments || 1338327952Sdim (NextNoComment && 1339327952Sdim NextNoComment->isOneOf(TT_DesignatedInitializerPeriod, 1340327952Sdim TT_DesignatedInitializerLSquare)); 1341321369Sdim BreakBeforeParameter = EndsInComma; 1342288943Sdim if (Current.ParameterCount > 1) 1343288943Sdim NestedBlockIndent = std::max(NestedBlockIndent, State.Column + 1); 1344276479Sdim } else { 1345276479Sdim NewIndent = Style.ContinuationIndentWidth + 1346276479Sdim std::max(State.Stack.back().LastSpace, 1347276479Sdim State.Stack.back().StartOfFunctionCall); 1348288943Sdim 1349288943Sdim // Ensure that different different brackets force relative alignment, e.g.: 1350288943Sdim // void SomeFunction(vector< // break 1351288943Sdim // int> v); 1352288943Sdim // FIXME: We likely want to do this for more combinations of brackets. 1353321369Sdim if (Current.is(tok::less) && Current.ParentBracket == tok::l_paren) { 1354288943Sdim NewIndent = std::max(NewIndent, State.Stack.back().Indent); 1355288943Sdim LastSpace = std::max(LastSpace, State.Stack.back().Indent); 1356288943Sdim } 1357288943Sdim 1358321369Sdim bool EndsInComma = 1359321369Sdim Current.MatchingParen && 1360321369Sdim Current.MatchingParen->getPreviousNonComment() && 1361321369Sdim Current.MatchingParen->getPreviousNonComment()->is(tok::comma); 1362321369Sdim 1363341825Sdim // If ObjCBinPackProtocolList is unspecified, fall back to BinPackParameters 1364341825Sdim // for backwards compatibility. 1365341825Sdim bool ObjCBinPackProtocolList = 1366341825Sdim (Style.ObjCBinPackProtocolList == FormatStyle::BPS_Auto && 1367341825Sdim Style.BinPackParameters) || 1368341825Sdim Style.ObjCBinPackProtocolList == FormatStyle::BPS_Always; 1369341825Sdim 1370341825Sdim bool BinPackDeclaration = 1371341825Sdim (State.Line->Type != LT_ObjCDecl && Style.BinPackParameters) || 1372341825Sdim (State.Line->Type == LT_ObjCDecl && ObjCBinPackProtocolList); 1373341825Sdim 1374280031Sdim AvoidBinPacking = 1375321369Sdim (Style.Language == FormatStyle::LK_JavaScript && EndsInComma) || 1376341825Sdim (State.Line->MustBeDeclaration && !BinPackDeclaration) || 1377280031Sdim (!State.Line->MustBeDeclaration && !Style.BinPackArguments) || 1378280031Sdim (Style.ExperimentalAutoDetectBinPacking && 1379280031Sdim (Current.PackingKind == PPK_OnePerLine || 1380280031Sdim (!BinPackInconclusiveFunctions && 1381280031Sdim Current.PackingKind == PPK_Inconclusive))); 1382321369Sdim 1383288943Sdim if (Current.is(TT_ObjCMethodExpr) && Current.MatchingParen) { 1384288943Sdim if (Style.ColumnLimit) { 1385288943Sdim // If this '[' opens an ObjC call, determine whether all parameters fit 1386288943Sdim // into one line and put one per line if they don't. 1387341825Sdim if (getLengthToMatchingParen(Current, State.Stack) + State.Column > 1388276479Sdim getColumnLimit(State)) 1389288943Sdim BreakBeforeParameter = true; 1390288943Sdim } else { 1391288943Sdim // For ColumnLimit = 0, we have to figure out whether there is or has to 1392288943Sdim // be a line break within this call. 1393288943Sdim for (const FormatToken *Tok = &Current; 1394288943Sdim Tok && Tok != Current.MatchingParen; Tok = Tok->Next) { 1395288943Sdim if (Tok->MustBreakBefore || 1396288943Sdim (Tok->CanBreakBefore && Tok->NewlinesBefore > 0)) { 1397288943Sdim BreakBeforeParameter = true; 1398288943Sdim break; 1399288943Sdim } 1400288943Sdim } 1401288943Sdim } 1402288943Sdim } 1403321369Sdim 1404321369Sdim if (Style.Language == FormatStyle::LK_JavaScript && EndsInComma) 1405321369Sdim BreakBeforeParameter = true; 1406276479Sdim } 1407296417Sdim // Generally inherit NoLineBreak from the current scope to nested scope. 1408296417Sdim // However, don't do this for non-empty nested blocks, dict literals and 1409296417Sdim // array literals as these follow different indentation rules. 1410296417Sdim bool NoLineBreak = 1411296417Sdim Current.Children.empty() && 1412296417Sdim !Current.isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) && 1413296417Sdim (State.Stack.back().NoLineBreak || 1414321369Sdim State.Stack.back().NoLineBreakInOperand || 1415296417Sdim (Current.is(TT_TemplateOpener) && 1416321369Sdim State.Stack.back().ContainsUnwrappedBuilder)); 1417321369Sdim State.Stack.push_back( 1418341825Sdim ParenState(&Current, NewIndent, LastSpace, AvoidBinPacking, NoLineBreak)); 1419280031Sdim State.Stack.back().NestedBlockIndent = NestedBlockIndent; 1420276479Sdim State.Stack.back().BreakBeforeParameter = BreakBeforeParameter; 1421276479Sdim State.Stack.back().HasMultipleNestedBlocks = Current.BlockParameterCount > 1; 1422341825Sdim State.Stack.back().IsInsideObjCArrayLiteral = 1423341825Sdim Current.is(TT_ArrayInitializerLSquare) && Current.Previous && 1424341825Sdim Current.Previous->is(tok::at); 1425276479Sdim} 1426276479Sdim 1427276479Sdimvoid ContinuationIndenter::moveStatePastScopeCloser(LineState &State) { 1428276479Sdim const FormatToken &Current = *State.NextToken; 1429276479Sdim if (!Current.closesScope()) 1430276479Sdim return; 1431276479Sdim 1432259701Sdim // If we encounter a closing ), ], } or >, we can remove a level from our 1433259701Sdim // stacks. 1434259701Sdim if (State.Stack.size() > 1 && 1435321369Sdim (Current.isOneOf(tok::r_paren, tok::r_square, TT_TemplateString) || 1436259701Sdim (Current.is(tok::r_brace) && State.NextToken != State.Line->First) || 1437341825Sdim State.NextToken->is(TT_TemplateCloser) || 1438341825Sdim (Current.is(tok::greater) && Current.is(TT_DictLiteral)))) 1439259701Sdim State.Stack.pop_back(); 1440276479Sdim 1441341825Sdim // Reevaluate whether ObjC message arguments fit into one line. 1442341825Sdim // If a receiver spans multiple lines, e.g.: 1443341825Sdim // [[object block:^{ 1444341825Sdim // return 42; 1445341825Sdim // }] a:42 b:42]; 1446341825Sdim // BreakBeforeParameter is calculated based on an incorrect assumption 1447341825Sdim // (it is checked whether the whole expression fits into one line without 1448341825Sdim // considering a line break inside a message receiver). 1449341825Sdim // We check whether arguements fit after receiver scope closer (into the same 1450341825Sdim // line). 1451341825Sdim if (State.Stack.back().BreakBeforeParameter && Current.MatchingParen && 1452341825Sdim Current.MatchingParen->Previous) { 1453341825Sdim const FormatToken &CurrentScopeOpener = *Current.MatchingParen->Previous; 1454341825Sdim if (CurrentScopeOpener.is(TT_ObjCMethodExpr) && 1455341825Sdim CurrentScopeOpener.MatchingParen) { 1456341825Sdim int NecessarySpaceInLine = 1457341825Sdim getLengthToMatchingParen(CurrentScopeOpener, State.Stack) + 1458341825Sdim CurrentScopeOpener.TotalLength - Current.TotalLength - 1; 1459341825Sdim if (State.Column + Current.ColumnWidth + NecessarySpaceInLine <= 1460341825Sdim Style.ColumnLimit) 1461341825Sdim State.Stack.back().BreakBeforeParameter = false; 1462341825Sdim } 1463341825Sdim } 1464341825Sdim 1465259701Sdim if (Current.is(tok::r_square)) { 1466259701Sdim // If this ends the array subscript expr, reset the corresponding value. 1467259701Sdim const FormatToken *NextNonComment = Current.getNextNonComment(); 1468259701Sdim if (NextNonComment && NextNonComment->isNot(tok::l_square)) 1469259701Sdim State.Stack.back().StartOfArraySubscripts = 0; 1470259701Sdim } 1471276479Sdim} 1472259701Sdim 1473276479Sdimvoid ContinuationIndenter::moveStateToNewBlock(LineState &State) { 1474280031Sdim unsigned NestedBlockIndent = State.Stack.back().NestedBlockIndent; 1475280031Sdim // ObjC block sometimes follow special indentation rules. 1476280031Sdim unsigned NewIndent = 1477280031Sdim NestedBlockIndent + (State.NextToken->is(TT_ObjCBlockLBrace) 1478280031Sdim ? Style.ObjCBlockIndentWidth 1479280031Sdim : Style.IndentWidth); 1480341825Sdim State.Stack.push_back(ParenState(State.NextToken, NewIndent, 1481341825Sdim State.Stack.back().LastSpace, 1482321369Sdim /*AvoidBinPacking=*/true, 1483321369Sdim /*NoLineBreak=*/false)); 1484280031Sdim State.Stack.back().NestedBlockIndent = NestedBlockIndent; 1485276479Sdim State.Stack.back().BreakBeforeParameter = true; 1486259701Sdim} 1487259701Sdim 1488327952Sdimstatic unsigned getLastLineEndColumn(StringRef Text, unsigned StartColumn, 1489327952Sdim unsigned TabWidth, 1490327952Sdim encoding::Encoding Encoding) { 1491327952Sdim size_t LastNewlinePos = Text.find_last_of("\n"); 1492327952Sdim if (LastNewlinePos == StringRef::npos) { 1493327952Sdim return StartColumn + 1494327952Sdim encoding::columnWidthWithTabs(Text, StartColumn, TabWidth, Encoding); 1495327952Sdim } else { 1496327952Sdim return encoding::columnWidthWithTabs(Text.substr(LastNewlinePos), 1497327952Sdim /*StartColumn=*/0, TabWidth, Encoding); 1498327952Sdim } 1499327952Sdim} 1500327952Sdim 1501327952Sdimunsigned ContinuationIndenter::reformatRawStringLiteral( 1502327952Sdim const FormatToken &Current, LineState &State, 1503353358Sdim const FormatStyle &RawStringStyle, bool DryRun, bool Newline) { 1504327952Sdim unsigned StartColumn = State.Column - Current.ColumnWidth; 1505341825Sdim StringRef OldDelimiter = *getRawStringDelimiter(Current.TokenText); 1506341825Sdim StringRef NewDelimiter = 1507341825Sdim getCanonicalRawStringDelimiter(Style, RawStringStyle.Language); 1508341825Sdim if (NewDelimiter.empty() || OldDelimiter.empty()) 1509341825Sdim NewDelimiter = OldDelimiter; 1510327952Sdim // The text of a raw string is between the leading 'R"delimiter(' and the 1511327952Sdim // trailing 'delimiter)"'. 1512341825Sdim unsigned OldPrefixSize = 3 + OldDelimiter.size(); 1513341825Sdim unsigned OldSuffixSize = 2 + OldDelimiter.size(); 1514341825Sdim // We create a virtual text environment which expects a null-terminated 1515341825Sdim // string, so we cannot use StringRef. 1516341825Sdim std::string RawText = 1517341825Sdim Current.TokenText.substr(OldPrefixSize).drop_back(OldSuffixSize); 1518341825Sdim if (NewDelimiter != OldDelimiter) { 1519341825Sdim // Don't update to the canonical delimiter 'deli' if ')deli"' occurs in the 1520341825Sdim // raw string. 1521341825Sdim std::string CanonicalDelimiterSuffix = (")" + NewDelimiter + "\"").str(); 1522341825Sdim if (StringRef(RawText).contains(CanonicalDelimiterSuffix)) 1523341825Sdim NewDelimiter = OldDelimiter; 1524341825Sdim } 1525327952Sdim 1526341825Sdim unsigned NewPrefixSize = 3 + NewDelimiter.size(); 1527341825Sdim unsigned NewSuffixSize = 2 + NewDelimiter.size(); 1528327952Sdim 1529341825Sdim // The first start column is the column the raw text starts after formatting. 1530341825Sdim unsigned FirstStartColumn = StartColumn + NewPrefixSize; 1531341825Sdim 1532327952Sdim // The next start column is the intended indentation a line break inside 1533327952Sdim // the raw string at level 0. It is determined by the following rules: 1534327952Sdim // - if the content starts on newline, it is one level more than the current 1535327952Sdim // indent, and 1536327952Sdim // - if the content does not start on a newline, it is the first start 1537327952Sdim // column. 1538327952Sdim // These rules have the advantage that the formatted content both does not 1539327952Sdim // violate the rectangle rule and visually flows within the surrounding 1540327952Sdim // source. 1541341825Sdim bool ContentStartsOnNewline = Current.TokenText[OldPrefixSize] == '\n'; 1542344779Sdim // If this token is the last parameter (checked by looking if it's followed by 1543353358Sdim // `)` and is not on a newline, the base the indent off the line's nested 1544353358Sdim // block indent. Otherwise, base the indent off the arguments indent, so we 1545353358Sdim // can achieve: 1546353358Sdim // 1547344779Sdim // fffffffffff(1, 2, 3, R"pb( 1548344779Sdim // key1: 1 # 1549344779Sdim // key2: 2)pb"); 1550344779Sdim // 1551344779Sdim // fffffffffff(1, 2, 3, 1552344779Sdim // R"pb( 1553344779Sdim // key1: 1 # 1554344779Sdim // key2: 2 1555353358Sdim // )pb"); 1556353358Sdim // 1557353358Sdim // fffffffffff(1, 2, 3, 1558353358Sdim // R"pb( 1559353358Sdim // key1: 1 # 1560353358Sdim // key2: 2 1561344779Sdim // )pb", 1562344779Sdim // 5); 1563353358Sdim unsigned CurrentIndent = 1564353358Sdim (!Newline && Current.Next && Current.Next->is(tok::r_paren)) 1565353358Sdim ? State.Stack.back().NestedBlockIndent 1566353358Sdim : State.Stack.back().Indent; 1567344779Sdim unsigned NextStartColumn = ContentStartsOnNewline 1568344779Sdim ? CurrentIndent + Style.IndentWidth 1569344779Sdim : FirstStartColumn; 1570327952Sdim 1571327952Sdim // The last start column is the column the raw string suffix starts if it is 1572327952Sdim // put on a newline. 1573327952Sdim // The last start column is the intended indentation of the raw string postfix 1574327952Sdim // if it is put on a newline. It is determined by the following rules: 1575327952Sdim // - if the raw string prefix starts on a newline, it is the column where 1576327952Sdim // that raw string prefix starts, and 1577327952Sdim // - if the raw string prefix does not start on a newline, it is the current 1578327952Sdim // indent. 1579353358Sdim unsigned LastStartColumn = 1580353358Sdim Current.NewlinesBefore ? FirstStartColumn - NewPrefixSize : CurrentIndent; 1581327952Sdim 1582327952Sdim std::pair<tooling::Replacements, unsigned> Fixes = internal::reformat( 1583327952Sdim RawStringStyle, RawText, {tooling::Range(0, RawText.size())}, 1584327952Sdim FirstStartColumn, NextStartColumn, LastStartColumn, "<stdin>", 1585327952Sdim /*Status=*/nullptr); 1586327952Sdim 1587327952Sdim auto NewCode = applyAllReplacements(RawText, Fixes.first); 1588327952Sdim tooling::Replacements NoFixes; 1589327952Sdim if (!NewCode) { 1590344779Sdim return addMultilineToken(Current, State); 1591327952Sdim } 1592327952Sdim if (!DryRun) { 1593341825Sdim if (NewDelimiter != OldDelimiter) { 1594341825Sdim // In 'R"delimiter(...', the delimiter starts 2 characters after the start 1595341825Sdim // of the token. 1596341825Sdim SourceLocation PrefixDelimiterStart = 1597341825Sdim Current.Tok.getLocation().getLocWithOffset(2); 1598341825Sdim auto PrefixErr = Whitespaces.addReplacement(tooling::Replacement( 1599341825Sdim SourceMgr, PrefixDelimiterStart, OldDelimiter.size(), NewDelimiter)); 1600341825Sdim if (PrefixErr) { 1601341825Sdim llvm::errs() 1602341825Sdim << "Failed to update the prefix delimiter of a raw string: " 1603341825Sdim << llvm::toString(std::move(PrefixErr)) << "\n"; 1604341825Sdim } 1605341825Sdim // In 'R"delimiter(...)delimiter"', the suffix delimiter starts at 1606341825Sdim // position length - 1 - |delimiter|. 1607341825Sdim SourceLocation SuffixDelimiterStart = 1608341825Sdim Current.Tok.getLocation().getLocWithOffset(Current.TokenText.size() - 1609341825Sdim 1 - OldDelimiter.size()); 1610341825Sdim auto SuffixErr = Whitespaces.addReplacement(tooling::Replacement( 1611341825Sdim SourceMgr, SuffixDelimiterStart, OldDelimiter.size(), NewDelimiter)); 1612341825Sdim if (SuffixErr) { 1613341825Sdim llvm::errs() 1614341825Sdim << "Failed to update the suffix delimiter of a raw string: " 1615341825Sdim << llvm::toString(std::move(SuffixErr)) << "\n"; 1616341825Sdim } 1617341825Sdim } 1618327952Sdim SourceLocation OriginLoc = 1619341825Sdim Current.Tok.getLocation().getLocWithOffset(OldPrefixSize); 1620327952Sdim for (const tooling::Replacement &Fix : Fixes.first) { 1621327952Sdim auto Err = Whitespaces.addReplacement(tooling::Replacement( 1622327952Sdim SourceMgr, OriginLoc.getLocWithOffset(Fix.getOffset()), 1623327952Sdim Fix.getLength(), Fix.getReplacementText())); 1624327952Sdim if (Err) { 1625327952Sdim llvm::errs() << "Failed to reformat raw string: " 1626327952Sdim << llvm::toString(std::move(Err)) << "\n"; 1627327952Sdim } 1628327952Sdim } 1629327952Sdim } 1630327952Sdim unsigned RawLastLineEndColumn = getLastLineEndColumn( 1631327952Sdim *NewCode, FirstStartColumn, Style.TabWidth, Encoding); 1632341825Sdim State.Column = RawLastLineEndColumn + NewSuffixSize; 1633341825Sdim // Since we're updating the column to after the raw string literal here, we 1634341825Sdim // have to manually add the penalty for the prefix R"delim( over the column 1635341825Sdim // limit. 1636341825Sdim unsigned PrefixExcessCharacters = 1637353358Sdim StartColumn + NewPrefixSize > Style.ColumnLimit 1638353358Sdim ? StartColumn + NewPrefixSize - Style.ColumnLimit 1639353358Sdim : 0; 1640344779Sdim bool IsMultiline = 1641344779Sdim ContentStartsOnNewline || (NewCode->find('\n') != std::string::npos); 1642344779Sdim if (IsMultiline) { 1643344779Sdim // Break before further function parameters on all levels. 1644344779Sdim for (unsigned i = 0, e = State.Stack.size(); i != e; ++i) 1645344779Sdim State.Stack[i].BreakBeforeParameter = true; 1646344779Sdim } 1647341825Sdim return Fixes.second + PrefixExcessCharacters * Style.PenaltyExcessCharacter; 1648327952Sdim} 1649327952Sdim 1650259701Sdimunsigned ContinuationIndenter::addMultilineToken(const FormatToken &Current, 1651259701Sdim LineState &State) { 1652259701Sdim // Break before further function parameters on all levels. 1653259701Sdim for (unsigned i = 0, e = State.Stack.size(); i != e; ++i) 1654259701Sdim State.Stack[i].BreakBeforeParameter = true; 1655259701Sdim 1656259701Sdim unsigned ColumnsUsed = State.Column; 1657259701Sdim // We can only affect layout of the first and the last line, so the penalty 1658259701Sdim // for all other lines is constant, and we ignore it. 1659259701Sdim State.Column = Current.LastLineColumnWidth; 1660259701Sdim 1661259701Sdim if (ColumnsUsed > getColumnLimit(State)) 1662259701Sdim return Style.PenaltyExcessCharacter * (ColumnsUsed - getColumnLimit(State)); 1663259701Sdim return 0; 1664259701Sdim} 1665259701Sdim 1666327952Sdimunsigned ContinuationIndenter::handleEndOfLine(const FormatToken &Current, 1667327952Sdim LineState &State, bool DryRun, 1668353358Sdim bool AllowBreak, bool Newline) { 1669327952Sdim unsigned Penalty = 0; 1670327952Sdim // Compute the raw string style to use in case this is a raw string literal 1671327952Sdim // that can be reformatted. 1672327952Sdim auto RawStringStyle = getRawStringStyle(Current, State); 1673341825Sdim if (RawStringStyle && !Current.Finalized) { 1674353358Sdim Penalty = reformatRawStringLiteral(Current, State, *RawStringStyle, DryRun, 1675353358Sdim Newline); 1676327952Sdim } else if (Current.IsMultiline && Current.isNot(TT_BlockComment)) { 1677327952Sdim // Don't break multi-line tokens other than block comments and raw string 1678327952Sdim // literals. Instead, just update the state. 1679327952Sdim Penalty = addMultilineToken(Current, State); 1680327952Sdim } else if (State.Line->Type != LT_ImportStatement) { 1681327952Sdim // We generally don't break import statements. 1682327952Sdim LineState OriginalState = State; 1683259701Sdim 1684327952Sdim // Whether we force the reflowing algorithm to stay strictly within the 1685327952Sdim // column limit. 1686327952Sdim bool Strict = false; 1687327952Sdim // Whether the first non-strict attempt at reflowing did intentionally 1688327952Sdim // exceed the column limit. 1689327952Sdim bool Exceeded = false; 1690327952Sdim std::tie(Penalty, Exceeded) = breakProtrudingToken( 1691327952Sdim Current, State, AllowBreak, /*DryRun=*/true, Strict); 1692327952Sdim if (Exceeded) { 1693327952Sdim // If non-strict reflowing exceeds the column limit, try whether strict 1694327952Sdim // reflowing leads to an overall lower penalty. 1695327952Sdim LineState StrictState = OriginalState; 1696327952Sdim unsigned StrictPenalty = 1697327952Sdim breakProtrudingToken(Current, StrictState, AllowBreak, 1698327952Sdim /*DryRun=*/true, /*Strict=*/true) 1699327952Sdim .first; 1700327952Sdim Strict = StrictPenalty <= Penalty; 1701327952Sdim if (Strict) { 1702327952Sdim Penalty = StrictPenalty; 1703327952Sdim State = StrictState; 1704327952Sdim } 1705327952Sdim } 1706327952Sdim if (!DryRun) { 1707327952Sdim // If we're not in dry-run mode, apply the changes with the decision on 1708327952Sdim // strictness made above. 1709327952Sdim breakProtrudingToken(Current, OriginalState, AllowBreak, /*DryRun=*/false, 1710327952Sdim Strict); 1711327952Sdim } 1712327952Sdim } 1713327952Sdim if (State.Column > getColumnLimit(State)) { 1714327952Sdim unsigned ExcessCharacters = State.Column - getColumnLimit(State); 1715327952Sdim Penalty += Style.PenaltyExcessCharacter * ExcessCharacters; 1716327952Sdim } 1717327952Sdim return Penalty; 1718327952Sdim} 1719259701Sdim 1720341825Sdim// Returns the enclosing function name of a token, or the empty string if not 1721341825Sdim// found. 1722341825Sdimstatic StringRef getEnclosingFunctionName(const FormatToken &Current) { 1723341825Sdim // Look for: 'function(' or 'function<templates>(' before Current. 1724341825Sdim auto Tok = Current.getPreviousNonComment(); 1725341825Sdim if (!Tok || !Tok->is(tok::l_paren)) 1726341825Sdim return ""; 1727341825Sdim Tok = Tok->getPreviousNonComment(); 1728341825Sdim if (!Tok) 1729341825Sdim return ""; 1730341825Sdim if (Tok->is(TT_TemplateCloser)) { 1731341825Sdim Tok = Tok->MatchingParen; 1732341825Sdim if (Tok) 1733341825Sdim Tok = Tok->getPreviousNonComment(); 1734341825Sdim } 1735341825Sdim if (!Tok || !Tok->is(tok::identifier)) 1736341825Sdim return ""; 1737341825Sdim return Tok->TokenText; 1738341825Sdim} 1739341825Sdim 1740327952Sdimllvm::Optional<FormatStyle> 1741327952SdimContinuationIndenter::getRawStringStyle(const FormatToken &Current, 1742327952Sdim const LineState &State) { 1743327952Sdim if (!Current.isStringLiteral()) 1744327952Sdim return None; 1745327952Sdim auto Delimiter = getRawStringDelimiter(Current.TokenText); 1746327952Sdim if (!Delimiter) 1747327952Sdim return None; 1748341825Sdim auto RawStringStyle = RawStringFormats.getDelimiterStyle(*Delimiter); 1749341825Sdim if (!RawStringStyle && Delimiter->empty()) 1750341825Sdim RawStringStyle = RawStringFormats.getEnclosingFunctionStyle( 1751341825Sdim getEnclosingFunctionName(Current)); 1752327952Sdim if (!RawStringStyle) 1753327952Sdim return None; 1754327952Sdim RawStringStyle->ColumnLimit = getColumnLimit(State); 1755327952Sdim return RawStringStyle; 1756327952Sdim} 1757259701Sdim 1758353358Sdimstd::unique_ptr<BreakableToken> 1759353358SdimContinuationIndenter::createBreakableToken(const FormatToken &Current, 1760353358Sdim LineState &State, bool AllowBreak) { 1761259701Sdim unsigned StartColumn = State.Column - Current.ColumnWidth; 1762276479Sdim if (Current.isStringLiteral()) { 1763353358Sdim // FIXME: String literal breaking is currently disabled for C#,Java and 1764353358Sdim // JavaScript, as it requires strings to be merged using "+" which we 1765353358Sdim // don't support. 1766280031Sdim if (Style.Language == FormatStyle::LK_Java || 1767353358Sdim Style.Language == FormatStyle::LK_JavaScript || Style.isCSharp() || 1768353358Sdim !Style.BreakStringLiterals || !AllowBreak) 1769327952Sdim return nullptr; 1770280031Sdim 1771259701Sdim // Don't break string literals inside preprocessor directives (except for 1772259701Sdim // #define directives, as their contents are stored in separate lines and 1773259701Sdim // are not affected by this check). 1774259701Sdim // This way we avoid breaking code with line directives and unknown 1775259701Sdim // preprocessor directives that contain long string literals. 1776259701Sdim if (State.Line->Type == LT_PreprocessorDirective) 1777327952Sdim return nullptr; 1778259701Sdim // Exempts unterminated string literals from line breaking. The user will 1779259701Sdim // likely want to terminate the string before any line breaking is done. 1780259701Sdim if (Current.IsUnterminatedLiteral) 1781327952Sdim return nullptr; 1782341825Sdim // Don't break string literals inside Objective-C array literals (doing so 1783341825Sdim // raises the warning -Wobjc-string-concatenation). 1784341825Sdim if (State.Stack.back().IsInsideObjCArrayLiteral) { 1785341825Sdim return nullptr; 1786341825Sdim } 1787259701Sdim 1788259701Sdim StringRef Text = Current.TokenText; 1789259701Sdim StringRef Prefix; 1790259701Sdim StringRef Postfix; 1791259701Sdim // FIXME: Handle whitespace between '_T', '(', '"..."', and ')'. 1792259701Sdim // FIXME: Store Prefix and Suffix (or PrefixLength and SuffixLength to 1793259701Sdim // reduce the overhead) for each FormatToken, which is a string, so that we 1794259701Sdim // don't run multiple checks here on the hot path. 1795259701Sdim if ((Text.endswith(Postfix = "\"") && 1796321369Sdim (Text.startswith(Prefix = "@\"") || Text.startswith(Prefix = "\"") || 1797276479Sdim Text.startswith(Prefix = "u\"") || Text.startswith(Prefix = "U\"") || 1798276479Sdim Text.startswith(Prefix = "u8\"") || 1799259701Sdim Text.startswith(Prefix = "L\""))) || 1800280031Sdim (Text.startswith(Prefix = "_T(\"") && Text.endswith(Postfix = "\")"))) { 1801341825Sdim // We need this to address the case where there is an unbreakable tail 1802341825Sdim // only if certain other formatting decisions have been taken. The 1803341825Sdim // UnbreakableTailLength of Current is an overapproximation is that case 1804341825Sdim // and we need to be correct here. 1805341825Sdim unsigned UnbreakableTailLength = (State.NextToken && canBreak(State)) 1806341825Sdim ? 0 1807341825Sdim : Current.UnbreakableTailLength; 1808360784Sdim return std::make_unique<BreakableStringLiteral>( 1809341825Sdim Current, StartColumn, Prefix, Postfix, UnbreakableTailLength, 1810341825Sdim State.Line->InPPDirective, Encoding, Style); 1811259701Sdim } 1812309124Sdim } else if (Current.is(TT_BlockComment)) { 1813327952Sdim if (!Style.ReflowComments || 1814321369Sdim // If a comment token switches formatting, like 1815321369Sdim // /* clang-format on */, we don't want to break it further, 1816321369Sdim // but we may still want to adjust its indentation. 1817327952Sdim switchesFormatting(Current)) { 1818327952Sdim return nullptr; 1819327952Sdim } 1820360784Sdim return std::make_unique<BreakableBlockComment>( 1821321369Sdim Current, StartColumn, Current.OriginalColumn, !Current.Previous, 1822353358Sdim State.Line->InPPDirective, Encoding, Style, Whitespaces.useCRLF()); 1823280031Sdim } else if (Current.is(TT_LineComment) && 1824276479Sdim (Current.Previous == nullptr || 1825280031Sdim Current.Previous->isNot(TT_ImplicitStringLiteral))) { 1826296417Sdim if (!Style.ReflowComments || 1827321369Sdim CommentPragmasRegex.match(Current.TokenText.substr(2)) || 1828321369Sdim switchesFormatting(Current)) 1829327952Sdim return nullptr; 1830360784Sdim return std::make_unique<BreakableLineCommentSection>( 1831321369Sdim Current, StartColumn, Current.OriginalColumn, !Current.Previous, 1832327952Sdim /*InPPDirective=*/false, Encoding, Style); 1833327952Sdim } 1834327952Sdim return nullptr; 1835327952Sdim} 1836327952Sdim 1837327952Sdimstd::pair<unsigned, bool> 1838327952SdimContinuationIndenter::breakProtrudingToken(const FormatToken &Current, 1839327952Sdim LineState &State, bool AllowBreak, 1840327952Sdim bool DryRun, bool Strict) { 1841327952Sdim std::unique_ptr<const BreakableToken> Token = 1842327952Sdim createBreakableToken(Current, State, AllowBreak); 1843327952Sdim if (!Token) 1844327952Sdim return {0, false}; 1845327952Sdim assert(Token->getLineCount() > 0); 1846327952Sdim unsigned ColumnLimit = getColumnLimit(State); 1847327952Sdim if (Current.is(TT_LineComment)) { 1848259701Sdim // We don't insert backslashes when breaking line comments. 1849259701Sdim ColumnLimit = Style.ColumnLimit; 1850259701Sdim } 1851259701Sdim if (Current.UnbreakableTailLength >= ColumnLimit) 1852327952Sdim return {0, false}; 1853327952Sdim // ColumnWidth was already accounted into State.Column before calling 1854327952Sdim // breakProtrudingToken. 1855327952Sdim unsigned StartColumn = State.Column - Current.ColumnWidth; 1856327952Sdim unsigned NewBreakPenalty = Current.isStringLiteral() 1857327952Sdim ? Style.PenaltyBreakString 1858327952Sdim : Style.PenaltyBreakComment; 1859327952Sdim // Stores whether we intentionally decide to let a line exceed the column 1860327952Sdim // limit. 1861327952Sdim bool Exceeded = false; 1862327952Sdim // Stores whether we introduce a break anywhere in the token. 1863327952Sdim bool BreakInserted = Token->introducesBreakBeforeToken(); 1864327952Sdim // Store whether we inserted a new line break at the end of the previous 1865327952Sdim // logical line. 1866327952Sdim bool NewBreakBefore = false; 1867321369Sdim // We use a conservative reflowing strategy. Reflow starts after a line is 1868321369Sdim // broken or the corresponding whitespace compressed. Reflow ends as soon as a 1869321369Sdim // line that doesn't get reflown with the previous line is reached. 1870327952Sdim bool Reflow = false; 1871327952Sdim // Keep track of where we are in the token: 1872327952Sdim // Where we are in the content of the current logical line. 1873327952Sdim unsigned TailOffset = 0; 1874327952Sdim // The column number we're currently at. 1875327952Sdim unsigned ContentStartColumn = 1876327952Sdim Token->getContentStartColumn(0, /*Break=*/false); 1877327952Sdim // The number of columns left in the current logical line after TailOffset. 1878327952Sdim unsigned RemainingTokenColumns = 1879327952Sdim Token->getRemainingLength(0, TailOffset, ContentStartColumn); 1880327952Sdim // Adapt the start of the token, for example indent. 1881327952Sdim if (!DryRun) 1882327952Sdim Token->adaptStartOfLine(0, Whitespaces); 1883327952Sdim 1884341825Sdim unsigned ContentIndent = 0; 1885259701Sdim unsigned Penalty = 0; 1886341825Sdim LLVM_DEBUG(llvm::dbgs() << "Breaking protruding token at column " 1887341825Sdim << StartColumn << ".\n"); 1888259701Sdim for (unsigned LineIndex = 0, EndIndex = Token->getLineCount(); 1889259701Sdim LineIndex != EndIndex; ++LineIndex) { 1890341825Sdim LLVM_DEBUG(llvm::dbgs() 1891341825Sdim << " Line: " << LineIndex << " (Reflow: " << Reflow << ")\n"); 1892327952Sdim NewBreakBefore = false; 1893327952Sdim // If we did reflow the previous line, we'll try reflowing again. Otherwise 1894327952Sdim // we'll start reflowing if the current line is broken or whitespace is 1895327952Sdim // compressed. 1896327952Sdim bool TryReflow = Reflow; 1897327952Sdim // Break the current token until we can fit the rest of the line. 1898327952Sdim while (ContentStartColumn + RemainingTokenColumns > ColumnLimit) { 1899341825Sdim LLVM_DEBUG(llvm::dbgs() << " Over limit, need: " 1900341825Sdim << (ContentStartColumn + RemainingTokenColumns) 1901341825Sdim << ", space: " << ColumnLimit 1902341825Sdim << ", reflown prefix: " << ContentStartColumn 1903341825Sdim << ", offset in line: " << TailOffset << "\n"); 1904327952Sdim // If the current token doesn't fit, find the latest possible split in the 1905327952Sdim // current line so that breaking at it will be under the column limit. 1906327952Sdim // FIXME: Use the earliest possible split while reflowing to correctly 1907327952Sdim // compress whitespace within a line. 1908327952Sdim BreakableToken::Split Split = 1909327952Sdim Token->getSplit(LineIndex, TailOffset, ColumnLimit, 1910327952Sdim ContentStartColumn, CommentPragmasRegex); 1911259701Sdim if (Split.first == StringRef::npos) { 1912327952Sdim // No break opportunity - update the penalty and continue with the next 1913327952Sdim // logical line. 1914259701Sdim if (LineIndex < EndIndex - 1) 1915344779Sdim // The last line's penalty is handled in addNextStateToQueue() or when 1916344779Sdim // calling replaceWhitespaceAfterLastLine below. 1917259701Sdim Penalty += Style.PenaltyExcessCharacter * 1918327952Sdim (ContentStartColumn + RemainingTokenColumns - ColumnLimit); 1919341825Sdim LLVM_DEBUG(llvm::dbgs() << " No break opportunity.\n"); 1920259701Sdim break; 1921259701Sdim } 1922259701Sdim assert(Split.first != 0); 1923259701Sdim 1924327952Sdim if (Token->supportsReflow()) { 1925327952Sdim // Check whether the next natural split point after the current one can 1926327952Sdim // still fit the line, either because we can compress away whitespace, 1927327952Sdim // or because the penalty the excess characters introduce is lower than 1928327952Sdim // the break penalty. 1929327952Sdim // We only do this for tokens that support reflowing, and thus allow us 1930327952Sdim // to change the whitespace arbitrarily (e.g. comments). 1931327952Sdim // Other tokens, like string literals, can be broken on arbitrary 1932327952Sdim // positions. 1933327952Sdim 1934327952Sdim // First, compute the columns from TailOffset to the next possible split 1935327952Sdim // position. 1936327952Sdim // For example: 1937327952Sdim // ColumnLimit: | 1938327952Sdim // // Some text that breaks 1939327952Sdim // ^ tail offset 1940327952Sdim // ^-- split 1941327952Sdim // ^-------- to split columns 1942327952Sdim // ^--- next split 1943327952Sdim // ^--------------- to next split columns 1944327952Sdim unsigned ToSplitColumns = Token->getRangeLength( 1945327952Sdim LineIndex, TailOffset, Split.first, ContentStartColumn); 1946341825Sdim LLVM_DEBUG(llvm::dbgs() << " ToSplit: " << ToSplitColumns << "\n"); 1947327952Sdim 1948327952Sdim BreakableToken::Split NextSplit = Token->getSplit( 1949327952Sdim LineIndex, TailOffset + Split.first + Split.second, ColumnLimit, 1950327952Sdim ContentStartColumn + ToSplitColumns + 1, CommentPragmasRegex); 1951327952Sdim // Compute the columns necessary to fit the next non-breakable sequence 1952327952Sdim // into the current line. 1953327952Sdim unsigned ToNextSplitColumns = 0; 1954327952Sdim if (NextSplit.first == StringRef::npos) { 1955327952Sdim ToNextSplitColumns = Token->getRemainingLength(LineIndex, TailOffset, 1956327952Sdim ContentStartColumn); 1957327952Sdim } else { 1958327952Sdim ToNextSplitColumns = Token->getRangeLength( 1959327952Sdim LineIndex, TailOffset, 1960327952Sdim Split.first + Split.second + NextSplit.first, ContentStartColumn); 1961327952Sdim } 1962327952Sdim // Compress the whitespace between the break and the start of the next 1963327952Sdim // unbreakable sequence. 1964327952Sdim ToNextSplitColumns = 1965327952Sdim Token->getLengthAfterCompression(ToNextSplitColumns, Split); 1966341825Sdim LLVM_DEBUG(llvm::dbgs() 1967341825Sdim << " ContentStartColumn: " << ContentStartColumn << "\n"); 1968341825Sdim LLVM_DEBUG(llvm::dbgs() 1969341825Sdim << " ToNextSplit: " << ToNextSplitColumns << "\n"); 1970327952Sdim // If the whitespace compression makes us fit, continue on the current 1971327952Sdim // line. 1972327952Sdim bool ContinueOnLine = 1973327952Sdim ContentStartColumn + ToNextSplitColumns <= ColumnLimit; 1974327952Sdim unsigned ExcessCharactersPenalty = 0; 1975327952Sdim if (!ContinueOnLine && !Strict) { 1976327952Sdim // Similarly, if the excess characters' penalty is lower than the 1977327952Sdim // penalty of introducing a new break, continue on the current line. 1978327952Sdim ExcessCharactersPenalty = 1979327952Sdim (ContentStartColumn + ToNextSplitColumns - ColumnLimit) * 1980327952Sdim Style.PenaltyExcessCharacter; 1981341825Sdim LLVM_DEBUG(llvm::dbgs() 1982341825Sdim << " Penalty excess: " << ExcessCharactersPenalty 1983341825Sdim << "\n break : " << NewBreakPenalty << "\n"); 1984327952Sdim if (ExcessCharactersPenalty < NewBreakPenalty) { 1985327952Sdim Exceeded = true; 1986327952Sdim ContinueOnLine = true; 1987327952Sdim } 1988327952Sdim } 1989327952Sdim if (ContinueOnLine) { 1990341825Sdim LLVM_DEBUG(llvm::dbgs() << " Continuing on line...\n"); 1991327952Sdim // The current line fits after compressing the whitespace - reflow 1992327952Sdim // the next line into it if possible. 1993327952Sdim TryReflow = true; 1994327952Sdim if (!DryRun) 1995327952Sdim Token->compressWhitespace(LineIndex, TailOffset, Split, 1996327952Sdim Whitespaces); 1997327952Sdim // When we continue on the same line, leave one space between content. 1998327952Sdim ContentStartColumn += ToSplitColumns + 1; 1999327952Sdim Penalty += ExcessCharactersPenalty; 2000327952Sdim TailOffset += Split.first + Split.second; 2001327952Sdim RemainingTokenColumns = Token->getRemainingLength( 2002327952Sdim LineIndex, TailOffset, ContentStartColumn); 2003327952Sdim continue; 2004327952Sdim } 2005259701Sdim } 2006341825Sdim LLVM_DEBUG(llvm::dbgs() << " Breaking...\n"); 2007341825Sdim // Update the ContentIndent only if the current line was not reflown with 2008341825Sdim // the previous line, since in that case the previous line should still 2009341825Sdim // determine the ContentIndent. Also never intent the last line. 2010341825Sdim if (!Reflow) 2011341825Sdim ContentIndent = Token->getContentIndent(LineIndex); 2012341825Sdim LLVM_DEBUG(llvm::dbgs() 2013341825Sdim << " ContentIndent: " << ContentIndent << "\n"); 2014341825Sdim ContentStartColumn = ContentIndent + Token->getContentStartColumn( 2015341825Sdim LineIndex, /*Break=*/true); 2016341825Sdim 2017327952Sdim unsigned NewRemainingTokenColumns = Token->getRemainingLength( 2018327952Sdim LineIndex, TailOffset + Split.first + Split.second, 2019327952Sdim ContentStartColumn); 2020341825Sdim if (NewRemainingTokenColumns == 0) { 2021341825Sdim // No content to indent. 2022341825Sdim ContentIndent = 0; 2023341825Sdim ContentStartColumn = 2024341825Sdim Token->getContentStartColumn(LineIndex, /*Break=*/true); 2025341825Sdim NewRemainingTokenColumns = Token->getRemainingLength( 2026341825Sdim LineIndex, TailOffset + Split.first + Split.second, 2027341825Sdim ContentStartColumn); 2028341825Sdim } 2029259701Sdim 2030276479Sdim // When breaking before a tab character, it may be moved by a few columns, 2031276479Sdim // but will still be expanded to the next tab stop, so we don't save any 2032276479Sdim // columns. 2033327952Sdim if (NewRemainingTokenColumns == RemainingTokenColumns) { 2034327952Sdim // FIXME: Do we need to adjust the penalty? 2035276479Sdim break; 2036327952Sdim } 2037327952Sdim assert(NewRemainingTokenColumns < RemainingTokenColumns); 2038276479Sdim 2039341825Sdim LLVM_DEBUG(llvm::dbgs() << " Breaking at: " << TailOffset + Split.first 2040341825Sdim << ", " << Split.second << "\n"); 2041259701Sdim if (!DryRun) 2042341825Sdim Token->insertBreak(LineIndex, TailOffset, Split, ContentIndent, 2043341825Sdim Whitespaces); 2044327952Sdim 2045327952Sdim Penalty += NewBreakPenalty; 2046259701Sdim TailOffset += Split.first + Split.second; 2047259701Sdim RemainingTokenColumns = NewRemainingTokenColumns; 2048259701Sdim BreakInserted = true; 2049327952Sdim NewBreakBefore = true; 2050259701Sdim } 2051327952Sdim // In case there's another line, prepare the state for the start of the next 2052327952Sdim // line. 2053327952Sdim if (LineIndex + 1 != EndIndex) { 2054327952Sdim unsigned NextLineIndex = LineIndex + 1; 2055327952Sdim if (NewBreakBefore) 2056327952Sdim // After breaking a line, try to reflow the next line into the current 2057327952Sdim // one once RemainingTokenColumns fits. 2058327952Sdim TryReflow = true; 2059327952Sdim if (TryReflow) { 2060327952Sdim // We decided that we want to try reflowing the next line into the 2061327952Sdim // current one. 2062327952Sdim // We will now adjust the state as if the reflow is successful (in 2063327952Sdim // preparation for the next line), and see whether that works. If we 2064327952Sdim // decide that we cannot reflow, we will later reset the state to the 2065327952Sdim // start of the next line. 2066327952Sdim Reflow = false; 2067327952Sdim // As we did not continue breaking the line, RemainingTokenColumns is 2068327952Sdim // known to fit after ContentStartColumn. Adapt ContentStartColumn to 2069327952Sdim // the position at which we want to format the next line if we do 2070327952Sdim // actually reflow. 2071327952Sdim // When we reflow, we need to add a space between the end of the current 2072327952Sdim // line and the next line's start column. 2073327952Sdim ContentStartColumn += RemainingTokenColumns + 1; 2074327952Sdim // Get the split that we need to reflow next logical line into the end 2075327952Sdim // of the current one; the split will include any leading whitespace of 2076327952Sdim // the next logical line. 2077327952Sdim BreakableToken::Split SplitBeforeNext = 2078327952Sdim Token->getReflowSplit(NextLineIndex, CommentPragmasRegex); 2079341825Sdim LLVM_DEBUG(llvm::dbgs() 2080341825Sdim << " Size of reflown text: " << ContentStartColumn 2081341825Sdim << "\n Potential reflow split: "); 2082327952Sdim if (SplitBeforeNext.first != StringRef::npos) { 2083341825Sdim LLVM_DEBUG(llvm::dbgs() << SplitBeforeNext.first << ", " 2084341825Sdim << SplitBeforeNext.second << "\n"); 2085327952Sdim TailOffset = SplitBeforeNext.first + SplitBeforeNext.second; 2086327952Sdim // If the rest of the next line fits into the current line below the 2087327952Sdim // column limit, we can safely reflow. 2088327952Sdim RemainingTokenColumns = Token->getRemainingLength( 2089327952Sdim NextLineIndex, TailOffset, ContentStartColumn); 2090327952Sdim Reflow = true; 2091327952Sdim if (ContentStartColumn + RemainingTokenColumns > ColumnLimit) { 2092341825Sdim LLVM_DEBUG(llvm::dbgs() 2093341825Sdim << " Over limit after reflow, need: " 2094341825Sdim << (ContentStartColumn + RemainingTokenColumns) 2095341825Sdim << ", space: " << ColumnLimit 2096341825Sdim << ", reflown prefix: " << ContentStartColumn 2097341825Sdim << ", offset in line: " << TailOffset << "\n"); 2098327952Sdim // If the whole next line does not fit, try to find a point in 2099327952Sdim // the next line at which we can break so that attaching the part 2100327952Sdim // of the next line to that break point onto the current line is 2101327952Sdim // below the column limit. 2102327952Sdim BreakableToken::Split Split = 2103327952Sdim Token->getSplit(NextLineIndex, TailOffset, ColumnLimit, 2104327952Sdim ContentStartColumn, CommentPragmasRegex); 2105327952Sdim if (Split.first == StringRef::npos) { 2106341825Sdim LLVM_DEBUG(llvm::dbgs() << " Did not find later break\n"); 2107327952Sdim Reflow = false; 2108327952Sdim } else { 2109327952Sdim // Check whether the first split point gets us below the column 2110327952Sdim // limit. Note that we will execute this split below as part of 2111327952Sdim // the normal token breaking and reflow logic within the line. 2112327952Sdim unsigned ToSplitColumns = Token->getRangeLength( 2113327952Sdim NextLineIndex, TailOffset, Split.first, ContentStartColumn); 2114327952Sdim if (ContentStartColumn + ToSplitColumns > ColumnLimit) { 2115341825Sdim LLVM_DEBUG(llvm::dbgs() << " Next split protrudes, need: " 2116341825Sdim << (ContentStartColumn + ToSplitColumns) 2117341825Sdim << ", space: " << ColumnLimit); 2118327952Sdim unsigned ExcessCharactersPenalty = 2119327952Sdim (ContentStartColumn + ToSplitColumns - ColumnLimit) * 2120327952Sdim Style.PenaltyExcessCharacter; 2121327952Sdim if (NewBreakPenalty < ExcessCharactersPenalty) { 2122327952Sdim Reflow = false; 2123327952Sdim } 2124327952Sdim } 2125327952Sdim } 2126327952Sdim } 2127327952Sdim } else { 2128341825Sdim LLVM_DEBUG(llvm::dbgs() << "not found.\n"); 2129327952Sdim } 2130327952Sdim } 2131327952Sdim if (!Reflow) { 2132327952Sdim // If we didn't reflow into the next line, the only space to consider is 2133327952Sdim // the next logical line. Reset our state to match the start of the next 2134327952Sdim // line. 2135327952Sdim TailOffset = 0; 2136327952Sdim ContentStartColumn = 2137327952Sdim Token->getContentStartColumn(NextLineIndex, /*Break=*/false); 2138327952Sdim RemainingTokenColumns = Token->getRemainingLength( 2139327952Sdim NextLineIndex, TailOffset, ContentStartColumn); 2140327952Sdim // Adapt the start of the token, for example indent. 2141327952Sdim if (!DryRun) 2142327952Sdim Token->adaptStartOfLine(NextLineIndex, Whitespaces); 2143327952Sdim } else { 2144327952Sdim // If we found a reflow split and have added a new break before the next 2145327952Sdim // line, we are going to remove the line break at the start of the next 2146327952Sdim // logical line. For example, here we'll add a new line break after 2147327952Sdim // 'text', and subsequently delete the line break between 'that' and 2148327952Sdim // 'reflows'. 2149327952Sdim // // some text that 2150327952Sdim // // reflows 2151327952Sdim // -> 2152327952Sdim // // some text 2153327952Sdim // // that reflows 2154327952Sdim // When adding the line break, we also added the penalty for it, so we 2155327952Sdim // need to subtract that penalty again when we remove the line break due 2156327952Sdim // to reflowing. 2157327952Sdim if (NewBreakBefore) { 2158327952Sdim assert(Penalty >= NewBreakPenalty); 2159327952Sdim Penalty -= NewBreakPenalty; 2160327952Sdim } 2161327952Sdim if (!DryRun) 2162327952Sdim Token->reflow(NextLineIndex, Whitespaces); 2163327952Sdim } 2164327952Sdim } 2165259701Sdim } 2166259701Sdim 2167327952Sdim BreakableToken::Split SplitAfterLastLine = 2168327952Sdim Token->getSplitAfterLastLine(TailOffset); 2169327952Sdim if (SplitAfterLastLine.first != StringRef::npos) { 2170341825Sdim LLVM_DEBUG(llvm::dbgs() << "Replacing whitespace after last line.\n"); 2171344779Sdim 2172344779Sdim // We add the last line's penalty here, since that line is going to be split 2173344779Sdim // now. 2174344779Sdim Penalty += Style.PenaltyExcessCharacter * 2175344779Sdim (ContentStartColumn + RemainingTokenColumns - ColumnLimit); 2176344779Sdim 2177327952Sdim if (!DryRun) 2178327952Sdim Token->replaceWhitespaceAfterLastLine(TailOffset, SplitAfterLastLine, 2179327952Sdim Whitespaces); 2180327952Sdim ContentStartColumn = 2181327952Sdim Token->getContentStartColumn(Token->getLineCount() - 1, /*Break=*/true); 2182327952Sdim RemainingTokenColumns = Token->getRemainingLength( 2183327952Sdim Token->getLineCount() - 1, 2184327952Sdim TailOffset + SplitAfterLastLine.first + SplitAfterLastLine.second, 2185327952Sdim ContentStartColumn); 2186327952Sdim } 2187259701Sdim 2188327952Sdim State.Column = ContentStartColumn + RemainingTokenColumns - 2189327952Sdim Current.UnbreakableTailLength; 2190327952Sdim 2191259701Sdim if (BreakInserted) { 2192259701Sdim // If we break the token inside a parameter list, we need to break before 2193259701Sdim // the next parameter on all levels, so that the next parameter is clearly 2194259701Sdim // visible. Line comments already introduce a break. 2195280031Sdim if (Current.isNot(TT_LineComment)) { 2196259701Sdim for (unsigned i = 0, e = State.Stack.size(); i != e; ++i) 2197259701Sdim State.Stack[i].BreakBeforeParameter = true; 2198259701Sdim } 2199259701Sdim 2200327952Sdim if (Current.is(TT_BlockComment)) 2201327952Sdim State.NoContinuation = true; 2202259701Sdim 2203259701Sdim State.Stack.back().LastSpace = StartColumn; 2204259701Sdim } 2205321369Sdim 2206321369Sdim Token->updateNextToken(State); 2207321369Sdim 2208327952Sdim return {Penalty, Exceeded}; 2209259701Sdim} 2210259701Sdim 2211259701Sdimunsigned ContinuationIndenter::getColumnLimit(const LineState &State) const { 2212259701Sdim // In preprocessor directives reserve two chars for trailing " \" 2213259701Sdim return Style.ColumnLimit - (State.Line->InPPDirective ? 2 : 0); 2214259701Sdim} 2215259701Sdim 2216276479Sdimbool ContinuationIndenter::nextIsMultilineString(const LineState &State) { 2217259701Sdim const FormatToken &Current = *State.NextToken; 2218280031Sdim if (!Current.isStringLiteral() || Current.is(TT_ImplicitStringLiteral)) 2219259701Sdim return false; 2220259701Sdim // We never consider raw string literals "multiline" for the purpose of 2221276479Sdim // AlwaysBreakBeforeMultilineStrings implementation as they are special-cased 2222276479Sdim // (see TokenAnnotator::mustBreakBefore(). 2223259701Sdim if (Current.TokenText.startswith("R\"")) 2224259701Sdim return false; 2225259701Sdim if (Current.IsMultiline) 2226259701Sdim return true; 2227259701Sdim if (Current.getNextNonComment() && 2228276479Sdim Current.getNextNonComment()->isStringLiteral()) 2229259701Sdim return true; // Implicit concatenation. 2230341825Sdim if (Style.ColumnLimit != 0 && Style.BreakStringLiterals && 2231288943Sdim State.Column + Current.ColumnWidth + Current.UnbreakableTailLength > 2232288943Sdim Style.ColumnLimit) 2233259701Sdim return true; // String will be split. 2234259701Sdim return false; 2235259701Sdim} 2236259701Sdim 2237259701Sdim} // namespace format 2238259701Sdim} // namespace clang 2239