ContinuationIndenter.cpp source code [clang_source_code/lib/Format/ContinuationIndenter.cpp]

1	//===--- ContinuationIndenter.cpp - Format C++ code -----------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	///
9	/// \file
10	/// This file implements the continuation indenter.
11	///
12	//===----------------------------------------------------------------------===//
13
14	#include "ContinuationIndenter.h"
15	#include "BreakableToken.h"
16	#include "FormatInternal.h"
17	#include "WhitespaceManager.h"
18	#include "clang/Basic/OperatorPrecedence.h"
19	#include "clang/Basic/SourceManager.h"
20	#include "clang/Format/Format.h"
21	#include "llvm/Support/Debug.h"
22
23	#define DEBUG_TYPE "format-indenter"
24
25	namespace clang {
26	namespace format {
27
28	// Returns true if a TT_SelectorName should be indented when wrapped,
29	// false otherwise.
30	static bool shouldIndentWrappedSelectorName(const FormatStyle &Style,
31	LineType LineType) {
32	return Style.IndentWrappedFunctionNames \|\| LineType == LT_ObjCMethodDecl;
33	}
34
35	// Returns the length of everything up to the first possible line break after
36	// the ), ], } or > matching \c Tok.
37	static unsigned getLengthToMatchingParen(const FormatToken &Tok,
38	const std::vector<ParenState> &Stack) {
39	// Normally whether or not a break before T is possible is calculated and
40	// stored in T.CanBreakBefore. Braces, array initializers and text proto
41	// messages like `key: < ... >` are an exception: a break is possible
42	// before a closing brace R if a break was inserted after the corresponding
43	// opening brace. The information about whether or not a break is needed
44	// before a closing brace R is stored in the ParenState field
45	// S.BreakBeforeClosingBrace where S is the state that R closes.
46	//
47	// In order to decide whether there can be a break before encountered right
48	// braces, this implementation iterates over the sequence of tokens and over
49	// the paren stack in lockstep, keeping track of the stack level which visited
50	// right braces correspond to in MatchingStackIndex.
51	//
52	// For example, consider:
53	// L. <- line number
54	// 1. {
55	// 2. {1},
56	// 3. {2},
57	// 4. {{3}}}
58	// ^ where we call this method with this token.
59	// The paren stack at this point contains 3 brace levels:
60	// 0. { at line 1, BreakBeforeClosingBrace: true
61	// 1. first { at line 4, BreakBeforeClosingBrace: false
62	// 2. second { at line 4, BreakBeforeClosingBrace: false,
63	// where there might be fake parens levels in-between these levels.
64	// The algorithm will start at the first } on line 4, which is the matching
65	// brace of the initial left brace and at level 2 of the stack. Then,
66	// examining BreakBeforeClosingBrace: false at level 2, it will continue to
67	// the second } on line 4, and will traverse the stack downwards until it
68	// finds the matching { on level 1. Then, examining BreakBeforeClosingBrace:
69	// false at level 1, it will continue to the third } on line 4 and will
70	// traverse the stack downwards until it finds the matching { on level 0.
71	// Then, examining BreakBeforeClosingBrace: true at level 0, the algorithm
72	// will stop and will use the second } on line 4 to determine the length to
73	// return, as in this example the range will include the tokens: {3}}
74	//
75	// The algorithm will only traverse the stack if it encounters braces, array
76	// initializer squares or text proto angle brackets.
77	if (!Tok.MatchingParen)
78	return 0;
79	FormatToken *End = Tok.MatchingParen;
80	// Maintains a stack level corresponding to the current End token.
81	int MatchingStackIndex = Stack.size() - 1;
82	// Traverses the stack downwards, looking for the level to which LBrace
83	// corresponds. Returns either a pointer to the matching level or nullptr if
84	// LParen is not found in the initial portion of the stack up to
85	// MatchingStackIndex.
86	auto FindParenState = [&](const FormatToken LBrace) -> const ParenState {
87	while (MatchingStackIndex >= 0 && Stack[MatchingStackIndex].Tok != LBrace)
88	--MatchingStackIndex;
89	return MatchingStackIndex >= 0 ? &Stack[MatchingStackIndex] : nullptr;
90	};
91	for (; End->Next; End = End->Next) {
92	if (End->Next->CanBreakBefore)
93	break;
94	if (!End->Next->closesScope())
95	continue;
96	if (End->Next->MatchingParen &&
97	End->Next->MatchingParen->isOneOf(
98	tok::l_brace, TT_ArrayInitializerLSquare, tok::less)) {
99	const ParenState *State = FindParenState(End->Next->MatchingParen);
100	if (State && State->BreakBeforeClosingBrace)
101	break;
102	}
103	}
104	return End->TotalLength - Tok.TotalLength + 1;
105	}
106
107	static unsigned getLengthToNextOperator(const FormatToken &Tok) {
108	if (!Tok.NextOperator)
109	return 0;
110	return Tok.NextOperator->TotalLength - Tok.TotalLength;
111	}
112
113	// Returns \c true if \c Tok is the "." or "->" of a call and starts the next
114	// segment of a builder type call.
115	static bool startsSegmentOfBuilderTypeCall(const FormatToken &Tok) {
116	return Tok.isMemberAccess() && Tok.Previous && Tok.Previous->closesScope();
117	}
118
119	// Returns \c true if \c Current starts a new parameter.
120	static bool startsNextParameter(const FormatToken &Current,
121	const FormatStyle &Style) {
122	const FormatToken &Previous = *Current.Previous;
123	if (Current.is(TT_CtorInitializerComma) &&
124	Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma)
125	return true;
126	if (Style.Language == FormatStyle::LK_Proto && Current.is(TT_SelectorName))
127	return true;
128	return Previous.is(tok::comma) && !Current.isTrailingComment() &&
129	((Previous.isNot(TT_CtorInitializerComma) \|\|
130	Style.BreakConstructorInitializers !=
131	FormatStyle::BCIS_BeforeComma) &&
132	(Previous.isNot(TT_InheritanceComma) \|\|
133	Style.BreakInheritanceList != FormatStyle::BILS_BeforeComma));
134	}
135
136	static bool opensProtoMessageField(const FormatToken &LessTok,
137	const FormatStyle &Style) {
138	if (LessTok.isNot(tok::less))
139	return false;
140	return Style.Language == FormatStyle::LK_TextProto \|\|
141	(Style.Language == FormatStyle::LK_Proto &&
142	(LessTok.NestingLevel > 0 \|\|
143	(LessTok.Previous && LessTok.Previous->is(tok::equal))));
144	}
145
146	// Returns the delimiter of a raw string literal, or None if TokenText is not
147	// the text of a raw string literal. The delimiter could be the empty string.
148	// For example, the delimiter of R"deli(cont)deli" is deli.
149	static llvm::Optional<StringRef> getRawStringDelimiter(StringRef TokenText) {
150	if (TokenText.size() < 5 // The smallest raw string possible is 'R"()"'.
151	\|\| !TokenText.startswith("R\"") \|\| !TokenText.endswith("\""))
152	return None;
153
154	// A raw string starts with 'R"<delimiter>(' and delimiter is ascii and has
155	// size at most 16 by the standard, so the first '(' must be among the first
156	// 19 bytes.
157	size_t LParenPos = TokenText.substr(0, 19).find_first_of('(');
158	if (LParenPos == StringRef::npos)
159	return None;
160	StringRef Delimiter = TokenText.substr(2, LParenPos - 2);
161
162	// Check that the string ends in ')Delimiter"'.
163	size_t RParenPos = TokenText.size() - Delimiter.size() - 2;
164	if (TokenText[RParenPos] != ')')
165	return None;
166	if (!TokenText.substr(RParenPos + 1).startswith(Delimiter))
167	return None;
168	return Delimiter;
169	}
170
171	// Returns the canonical delimiter for \p Language, or the empty string if no
172	// canonical delimiter is specified.
173	static StringRef
174	getCanonicalRawStringDelimiter(const FormatStyle &Style,
175	FormatStyle::LanguageKind Language) {
176	for (const auto &Format : Style.RawStringFormats) {
177	if (Format.Language == Language)
178	return StringRef(Format.CanonicalDelimiter);
179	}
180	return "";
181	}
182
183	RawStringFormatStyleManager::RawStringFormatStyleManager(
184	const FormatStyle &CodeStyle) {
185	for (const auto &RawStringFormat : CodeStyle.RawStringFormats) {
186	llvm::Optional<FormatStyle> LanguageStyle =
187	CodeStyle.GetLanguageStyle(RawStringFormat.Language);
188	if (!LanguageStyle) {
189	FormatStyle PredefinedStyle;
190	if (!getPredefinedStyle(RawStringFormat.BasedOnStyle,
191	RawStringFormat.Language, &PredefinedStyle)) {
192	PredefinedStyle = getLLVMStyle();
193	PredefinedStyle.Language = RawStringFormat.Language;
194	}
195	LanguageStyle = PredefinedStyle;
196	}
197	LanguageStyle->ColumnLimit = CodeStyle.ColumnLimit;
198	for (StringRef Delimiter : RawStringFormat.Delimiters) {
199	DelimiterStyle.insert({Delimiter, *LanguageStyle});
200	}
201	for (StringRef EnclosingFunction : RawStringFormat.EnclosingFunctions) {
202	EnclosingFunctionStyle.insert({EnclosingFunction, *LanguageStyle});
203	}
204	}
205	}
206
207	llvm::Optional<FormatStyle>
208	RawStringFormatStyleManager::getDelimiterStyle(StringRef Delimiter) const {
209	auto It = DelimiterStyle.find(Delimiter);
210	if (It == DelimiterStyle.end())
211	return None;
212	return It->second;
213	}
214
215	llvm::Optional<FormatStyle>
216	RawStringFormatStyleManager::getEnclosingFunctionStyle(
217	StringRef EnclosingFunction) const {
218	auto It = EnclosingFunctionStyle.find(EnclosingFunction);
219	if (It == EnclosingFunctionStyle.end())
220	return None;
221	return It->second;
222	}
223
224	ContinuationIndenter::ContinuationIndenter(const FormatStyle &Style,
225	const AdditionalKeywords &Keywords,
226	const SourceManager &SourceMgr,
227	WhitespaceManager &Whitespaces,
228	encoding::Encoding Encoding,
229	bool BinPackInconclusiveFunctions)
230	: Style(Style), Keywords(Keywords), SourceMgr(SourceMgr),
231	Whitespaces(Whitespaces), Encoding(Encoding),
232	BinPackInconclusiveFunctions(BinPackInconclusiveFunctions),
233	CommentPragmasRegex(Style.CommentPragmas), RawStringFormats(Style) {}
234
235	LineState ContinuationIndenter::getInitialState(unsigned FirstIndent,
236	unsigned FirstStartColumn,
237	const AnnotatedLine *Line,
238	bool DryRun) {
239	LineState State;
240	State.FirstIndent = FirstIndent;
241	if (FirstStartColumn && Line->First->NewlinesBefore == 0)
242	State.Column = FirstStartColumn;
243	else
244	State.Column = FirstIndent;
245	// With preprocessor directive indentation, the line starts on column 0
246	// since it's indented after the hash, but FirstIndent is set to the
247	// preprocessor indent.
248	if (Style.IndentPPDirectives == FormatStyle::PPDIS_AfterHash &&
249	(Line->Type == LT_PreprocessorDirective \|\|
250	Line->Type == LT_ImportStatement))
251	State.Column = 0;
252	State.Line = Line;
253	State.NextToken = Line->First;
254	State.Stack.push_back(ParenState(/Tok=/nullptr, FirstIndent, FirstIndent,
255	/AvoidBinPacking=/false,
256	/NoLineBreak=/false));
257	State.LineContainsContinuedForLoopSection = false;
258	State.NoContinuation = false;
259	State.StartOfStringLiteral = 0;
260	State.StartOfLineLevel = 0;
261	State.LowestLevelOnLine = 0;
262	State.IgnoreStackForComparison = false;
263
264	if (Style.Language == FormatStyle::LK_TextProto) {
265	// We need this in order to deal with the bin packing of text fields at
266	// global scope.
267	State.Stack.back().AvoidBinPacking = true;
268	State.Stack.back().BreakBeforeParameter = true;
269	State.Stack.back().AlignColons = false;
270	}
271
272	// The first token has already been indented and thus consumed.
273	moveStateToNextToken(State, DryRun, /Newline=/false);
274	return State;
275	}
276
277	bool ContinuationIndenter::canBreak(const LineState &State) {
278	const FormatToken &Current = *State.NextToken;
279	const FormatToken &Previous = *Current.Previous;
280	assert(&Previous == Current.Previous);
281	if (!Current.CanBreakBefore && !(State.Stack.back().BreakBeforeClosingBrace &&
282	Current.closesBlockOrBlockTypeList(Style)))
283	return false;
284	// The opening "{" of a braced list has to be on the same line as the first
285	// element if it is nested in another braced init list or function call.
286	if (!Current.MustBreakBefore && Previous.is(tok::l_brace) &&
287	Previous.isNot(TT_DictLiteral) && Previous.BlockKind == BK_BracedInit &&
288	Previous.Previous &&
289	Previous.Previous->isOneOf(tok::l_brace, tok::l_paren, tok::comma))
290	return false;
291	// This prevents breaks like:
292	// ...
293	// SomeParameter, OtherParameter).DoSomething(
294	// ...
295	// As they hide "DoSomething" and are generally bad for readability.
296	if (Previous.opensScope() && Previous.isNot(tok::l_brace) &&
297	State.LowestLevelOnLine < State.StartOfLineLevel &&
298	State.LowestLevelOnLine < Current.NestingLevel)
299	return false;
300	if (Current.isMemberAccess() && State.Stack.back().ContainsUnwrappedBuilder)
301	return false;
302
303	// Don't create a 'hanging' indent if there are multiple blocks in a single
304	// statement.
305	if (Previous.is(tok::l_brace) && State.Stack.size() > 1 &&
306	State.Stack[State.Stack.size() - 2].NestedBlockInlined &&
307	State.Stack[State.Stack.size() - 2].HasMultipleNestedBlocks)
308	return false;
309
310	// Don't break after very short return types (e.g. "void") as that is often
311	// unexpected.
312	if (Current.is(TT_FunctionDeclarationName) && State.Column < 6) {
313	if (Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None)
314	return false;
315	}
316
317	// If binary operators are moved to the next line (including commas for some
318	// styles of constructor initializers), that's always ok.
319	if (!Current.isOneOf(TT_BinaryOperator, tok::comma) &&
320	State.Stack.back().NoLineBreakInOperand)
321	return false;
322
323	if (Previous.is(tok::l_square) && Previous.is(TT_ObjCMethodExpr))
324	return false;
325
326	return !State.Stack.back().NoLineBreak;
327	}
328
329	bool ContinuationIndenter::mustBreak(const LineState &State) {
330	const FormatToken &Current = *State.NextToken;
331	const FormatToken &Previous = *Current.Previous;
332	if (Current.MustBreakBefore \|\| Current.is(TT_InlineASMColon))
333	return true;
334	if (State.Stack.back().BreakBeforeClosingBrace &&
335	Current.closesBlockOrBlockTypeList(Style))
336	return true;
337	if (Previous.is(tok::semi) && State.LineContainsContinuedForLoopSection)
338	return true;
339	if (Style.Language == FormatStyle::LK_ObjC &&
340	Current.ObjCSelectorNameParts > 1 &&
341	Current.startsSequence(TT_SelectorName, tok::colon, tok::caret)) {
342	return true;
343	}
344	if ((startsNextParameter(Current, Style) \|\| Previous.is(tok::semi) \|\|
345	(Previous.is(TT_TemplateCloser) && Current.is(TT_StartOfName) &&
346	Style.isCpp() &&
347	// FIXME: This is a temporary workaround for the case where clang-format
348	// sets BreakBeforeParameter to avoid bin packing and this creates a
349	// completely unnecessary line break after a template type that isn't
350	// line-wrapped.
351	(Previous.NestingLevel == 1 \|\| Style.BinPackParameters)) \|\|
352	(Style.BreakBeforeTernaryOperators && Current.is(TT_ConditionalExpr) &&
353	Previous.isNot(tok::question)) \|\|
354	(!Style.BreakBeforeTernaryOperators &&
355	Previous.is(TT_ConditionalExpr))) &&
356	State.Stack.back().BreakBeforeParameter && !Current.isTrailingComment() &&
357	!Current.isOneOf(tok::r_paren, tok::r_brace))
358	return true;
359	if (((Previous.is(TT_DictLiteral) && Previous.is(tok::l_brace)) \|\|
360	(Previous.is(TT_ArrayInitializerLSquare) &&
361	Previous.ParameterCount > 1) \|\|
362	opensProtoMessageField(Previous, Style)) &&
363	Style.ColumnLimit > 0 &&
364	getLengthToMatchingParen(Previous, State.Stack) + State.Column - 1 >
365	getColumnLimit(State))
366	return true;
367
368	const FormatToken &BreakConstructorInitializersToken =
369	Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon
370	? Previous
371	: Current;
372	if (BreakConstructorInitializersToken.is(TT_CtorInitializerColon) &&
373	(State.Column + State.Line->Last->TotalLength - Previous.TotalLength >
374	getColumnLimit(State) \|\|
375	State.Stack.back().BreakBeforeParameter) &&
376	(Style.AllowShortFunctionsOnASingleLine != FormatStyle::SFS_All \|\|
377	Style.BreakConstructorInitializers != FormatStyle::BCIS_BeforeColon \|\|
378	Style.ColumnLimit != 0))
379	return true;
380
381	if (Current.is(TT_ObjCMethodExpr) && !Previous.is(TT_SelectorName) &&
382	State.Line->startsWith(TT_ObjCMethodSpecifier))
383	return true;
384	if (Current.is(TT_SelectorName) && !Previous.is(tok::at) &&
385	State.Stack.back().ObjCSelectorNameFound &&
386	State.Stack.back().BreakBeforeParameter)
387	return true;
388
389	unsigned NewLineColumn = getNewLineColumn(State);
390	if (Current.isMemberAccess() && Style.ColumnLimit != 0 &&
391	State.Column + getLengthToNextOperator(Current) > Style.ColumnLimit &&
392	(State.Column > NewLineColumn \|\|
393	Current.NestingLevel < State.StartOfLineLevel))
394	return true;
395
396	if (startsSegmentOfBuilderTypeCall(Current) &&
397	(State.Stack.back().CallContinuation != 0 \|\|
398	State.Stack.back().BreakBeforeParameter) &&
399	// JavaScript is treated different here as there is a frequent pattern:
400	// SomeFunction(function() {
401	// ...
402	// }.bind(...));
403	// FIXME: We should find a more generic solution to this problem.
404	!(State.Column <= NewLineColumn &&
405	Style.Language == FormatStyle::LK_JavaScript) &&
406	!(Previous.closesScopeAfterBlock() && State.Column <= NewLineColumn))
407	return true;
408
409	// If the template declaration spans multiple lines, force wrap before the
410	// function/class declaration
411	if (Previous.ClosesTemplateDeclaration &&
412	State.Stack.back().BreakBeforeParameter && Current.CanBreakBefore)
413	return true;
414
415	if (State.Column <= NewLineColumn)
416	return false;
417
418	if (Style.AlwaysBreakBeforeMultilineStrings &&
419	(NewLineColumn == State.FirstIndent + Style.ContinuationIndentWidth \|\|
420	Previous.is(tok::comma) \|\| Current.NestingLevel < 2) &&
421	!Previous.isOneOf(tok::kw_return, tok::lessless, tok::at,
422	Keywords.kw_dollar) &&
423	!Previous.isOneOf(TT_InlineASMColon, TT_ConditionalExpr) &&
424	nextIsMultilineString(State))
425	return true;
426
427	// Using CanBreakBefore here and below takes care of the decision whether the
428	// current style uses wrapping before or after operators for the given
429	// operator.
430	if (Previous.is(TT_BinaryOperator) && Current.CanBreakBefore) {
431	// If we need to break somewhere inside the LHS of a binary expression, we
432	// should also break after the operator. Otherwise, the formatting would
433	// hide the operator precedence, e.g. in:
434	// if (aaaaaaaaaaaaaa ==
435	// bbbbbbbbbbbbbb && c) {..
436	// For comparisons, we only apply this rule, if the LHS is a binary
437	// expression itself as otherwise, the line breaks seem superfluous.
438	// We need special cases for ">>" which we have split into two ">" while
439	// lexing in order to make template parsing easier.
440	bool IsComparison = (Previous.getPrecedence() == prec::Relational \|\|
441	Previous.getPrecedence() == prec::Equality \|\|
442	Previous.getPrecedence() == prec::Spaceship) &&
443	Previous.Previous &&
444	Previous.Previous->isNot(TT_BinaryOperator); // For >>.
445	bool LHSIsBinaryExpr =
446	Previous.Previous && Previous.Previous->EndsBinaryExpression;
447	if ((!IsComparison \|\| LHSIsBinaryExpr) && !Current.isTrailingComment() &&
448	Previous.getPrecedence() != prec::Assignment &&
449	State.Stack.back().BreakBeforeParameter)
450	return true;
451	} else if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore &&
452	State.Stack.back().BreakBeforeParameter) {
453	return true;
454	}
455
456	// Same as above, but for the first "<<" operator.
457	if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator) &&
458	State.Stack.back().BreakBeforeParameter &&
459	State.Stack.back().FirstLessLess == 0)
460	return true;
461
462	if (Current.NestingLevel == 0 && !Current.isTrailingComment()) {
463	// Always break after "template <...>" and leading annotations. This is only
464	// for cases where the entire line does not fit on a single line as a
465	// different LineFormatter would be used otherwise.
466	if (Previous.ClosesTemplateDeclaration)
467	return Style.AlwaysBreakTemplateDeclarations != FormatStyle::BTDS_No;
468	if (Previous.is(TT_FunctionAnnotationRParen))
469	return true;
470	if (Previous.is(TT_LeadingJavaAnnotation) && Current.isNot(tok::l_paren) &&
471	Current.isNot(TT_LeadingJavaAnnotation))
472	return true;
473	}
474
475	// If the return type spans multiple lines, wrap before the function name.
476	if ((Current.is(TT_FunctionDeclarationName) \|\|
477	(Current.is(tok::kw_operator) && !Previous.is(tok::coloncolon))) &&
478	!Previous.is(tok::kw_template) && State.Stack.back().BreakBeforeParameter)
479	return true;
480
481	// The following could be precomputed as they do not depend on the state.
482	// However, as they should take effect only if the UnwrappedLine does not fit
483	// into the ColumnLimit, they are checked here in the ContinuationIndenter.
484	if (Style.ColumnLimit != 0 && Previous.BlockKind == BK_Block &&
485	Previous.is(tok::l_brace) && !Current.isOneOf(tok::r_brace, tok::comment))
486	return true;
487
488	if (Current.is(tok::lessless) &&
489	((Previous.is(tok::identifier) && Previous.TokenText == "endl") \|\|
490	(Previous.Tok.isLiteral() && (Previous.TokenText.endswith("\\n\"") \|\|
491	Previous.TokenText == "\'\\n\'"))))
492	return true;
493
494	if (Previous.is(TT_BlockComment) && Previous.IsMultiline)
495	return true;
496
497	if (State.NoContinuation)
498	return true;
499
500	return false;
501	}
502
503	unsigned ContinuationIndenter::addTokenToState(LineState &State, bool Newline,
504	bool DryRun,
505	unsigned ExtraSpaces) {
506	const FormatToken &Current = *State.NextToken;
507
508	assert(!State.Stack.empty());
509	State.NoContinuation = false;
510
511	if ((Current.is(TT_ImplicitStringLiteral) &&
512	(Current.Previous->Tok.getIdentifierInfo() == nullptr \|\|
513	Current.Previous->Tok.getIdentifierInfo()->getPPKeywordID() ==
514	tok::pp_not_keyword))) {
515	unsigned EndColumn =
516	SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getEnd());
517	if (Current.LastNewlineOffset != 0) {
518	// If there is a newline within this token, the final column will solely
519	// determined by the current end column.
520	State.Column = EndColumn;
521	} else {
522	unsigned StartColumn =
523	SourceMgr.getSpellingColumnNumber(Current.WhitespaceRange.getBegin());
524	= StartColumn", "/home/seafit/code_projects/clang_source/clang/lib/Format/ContinuationIndenter.cpp", 524, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(EndColumn >= StartColumn);
525	State.Column += EndColumn - StartColumn;
526	}
527	moveStateToNextToken(State, DryRun, /Newline=/false);
528	return 0;
529	}
530
531	unsigned Penalty = 0;
532	if (Newline)
533	Penalty = addTokenOnNewLine(State, DryRun);
534	else
535	addTokenOnCurrentLine(State, DryRun, ExtraSpaces);
536
537	return moveStateToNextToken(State, DryRun, Newline) + Penalty;
538	}
539
540	void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
541	unsigned ExtraSpaces) {
542	FormatToken &Current = *State.NextToken;
543	const FormatToken &Previous = *State.NextToken->Previous;
544	if (Current.is(tok::equal) &&
545	(State.Line->First->is(tok::kw_for) \|\| Current.NestingLevel == 0) &&
546	State.Stack.back().VariablePos == 0) {
547	State.Stack.back().VariablePos = State.Column;
548	// Move over * and & if they are bound to the variable name.
549	const FormatToken *Tok = &Previous;
550	while (Tok && State.Stack.back().VariablePos >= Tok->ColumnWidth) {
551	State.Stack.back().VariablePos -= Tok->ColumnWidth;
552	if (Tok->SpacesRequiredBefore != 0)
553	break;
554	Tok = Tok->Previous;
555	}
556	if (Previous.PartOfMultiVariableDeclStmt)
557	State.Stack.back().LastSpace = State.Stack.back().VariablePos;
558	}
559
560	unsigned Spaces = Current.SpacesRequiredBefore + ExtraSpaces;
561
562	// Indent preprocessor directives after the hash if required.
563	int PPColumnCorrection = 0;
564	if (Style.IndentPPDirectives == FormatStyle::PPDIS_AfterHash &&
565	Previous.is(tok::hash) && State.FirstIndent > 0 &&
566	(State.Line->Type == LT_PreprocessorDirective \|\|
567	State.Line->Type == LT_ImportStatement)) {
568	Spaces += State.FirstIndent;
569
570	// For preprocessor indent with tabs, State.Column will be 1 because of the
571	// hash. This causes second-level indents onward to have an extra space
572	// after the tabs. We avoid this misalignment by subtracting 1 from the
573	// column value passed to replaceWhitespace().
574	if (Style.UseTab != FormatStyle::UT_Never)
575	PPColumnCorrection = -1;
576	}
577
578	if (!DryRun)
579	Whitespaces.replaceWhitespace(Current, /Newlines=/0, Spaces,
580	State.Column + Spaces + PPColumnCorrection);
581
582	// If "BreakBeforeInheritanceComma" mode, don't break within the inheritance
583	// declaration unless there is multiple inheritance.
584	if (Style.BreakInheritanceList == FormatStyle::BILS_BeforeComma &&
585	Current.is(TT_InheritanceColon))
586	State.Stack.back().NoLineBreak = true;
587	if (Style.BreakInheritanceList == FormatStyle::BILS_AfterColon &&
588	Previous.is(TT_InheritanceColon))
589	State.Stack.back().NoLineBreak = true;
590
591	if (Current.is(TT_SelectorName) &&
592	!State.Stack.back().ObjCSelectorNameFound) {
593	unsigned MinIndent =
594	std::max(State.FirstIndent + Style.ContinuationIndentWidth,
595	State.Stack.back().Indent);
596	unsigned FirstColonPos = State.Column + Spaces + Current.ColumnWidth;
597	if (Current.LongestObjCSelectorName == 0)
598	State.Stack.back().AlignColons = false;
599	else if (MinIndent + Current.LongestObjCSelectorName > FirstColonPos)
600	State.Stack.back().ColonPos = MinIndent + Current.LongestObjCSelectorName;
601	else
602	State.Stack.back().ColonPos = FirstColonPos;
603	}
604
605	// In "AlwaysBreak" mode, enforce wrapping directly after the parenthesis by
606	// disallowing any further line breaks if there is no line break after the
607	// opening parenthesis. Don't break if it doesn't conserve columns.
608	if (Style.AlignAfterOpenBracket == FormatStyle::BAS_AlwaysBreak &&
609	Previous.isOneOf(tok::l_paren, TT_TemplateOpener, tok::l_square) &&
610	State.Column > getNewLineColumn(State) &&
611	(!Previous.Previous \|\| !Previous.Previous->isOneOf(
612	tok::kw_for, tok::kw_while, tok::kw_switch)) &&
613	// Don't do this for simple (no expressions) one-argument function calls
614	// as that feels like needlessly wasting whitespace, e.g.:
615	//
616	// caaaaaaaaaaaall(
617	// caaaaaaaaaaaall(
618	// caaaaaaaaaaaall(
619	// caaaaaaaaaaaaaaaaaaaaaaall(aaaaaaaaaaaaaa, aaaaaaaaa))));
620	Current.FakeLParens.size() > 0 &&
621	Current.FakeLParens.back() > prec::Unknown)
622	State.Stack.back().NoLineBreak = true;
623	if (Previous.is(TT_TemplateString) && Previous.opensScope())
624	State.Stack.back().NoLineBreak = true;
625
626	if (Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign &&
627	Previous.opensScope() && Previous.isNot(TT_ObjCMethodExpr) &&
628	(Current.isNot(TT_LineComment) \|\| Previous.BlockKind == BK_BracedInit))
629	State.Stack.back().Indent = State.Column + Spaces;
630	if (State.Stack.back().AvoidBinPacking && startsNextParameter(Current, Style))
631	State.Stack.back().NoLineBreak = true;
632	if (startsSegmentOfBuilderTypeCall(Current) &&
633	State.Column > getNewLineColumn(State))
634	State.Stack.back().ContainsUnwrappedBuilder = true;
635
636	if (Current.is(TT_LambdaArrow) && Style.Language == FormatStyle::LK_Java)
637	State.Stack.back().NoLineBreak = true;
638	if (Current.isMemberAccess() && Previous.is(tok::r_paren) &&
639	(Previous.MatchingParen &&
640	(Previous.TotalLength - Previous.MatchingParen->TotalLength > 10)))
641	// If there is a function call with long parameters, break before trailing
642	// calls. This prevents things like:
643	// EXPECT_CALL(SomeLongParameter).Times(
644	// 2);
645	// We don't want to do this for short parameters as they can just be
646	// indexes.
647	State.Stack.back().NoLineBreak = true;
648
649	// Don't allow the RHS of an operator to be split over multiple lines unless
650	// there is a line-break right after the operator.
651	// Exclude relational operators, as there, it is always more desirable to
652	// have the LHS 'left' of the RHS.
653	const FormatToken *P = Current.getPreviousNonComment();
654	if (!Current.is(tok::comment) && P &&
655	(P->isOneOf(TT_BinaryOperator, tok::comma) \|\|
656	(P->is(TT_ConditionalExpr) && P->is(tok::colon))) &&
657	!P->isOneOf(TT_OverloadedOperator, TT_CtorInitializerComma) &&
658	P->getPrecedence() != prec::Assignment &&
659	P->getPrecedence() != prec::Relational &&
660	P->getPrecedence() != prec::Spaceship) {
661	bool BreakBeforeOperator =
662	P->MustBreakBefore \|\| P->is(tok::lessless) \|\|
663	(P->is(TT_BinaryOperator) &&
664	Style.BreakBeforeBinaryOperators != FormatStyle::BOS_None) \|\|
665	(P->is(TT_ConditionalExpr) && Style.BreakBeforeTernaryOperators);
666	// Don't do this if there are only two operands. In these cases, there is
667	// always a nice vertical separation between them and the extra line break
668	// does not help.
669	bool HasTwoOperands =
670	P->OperatorIndex == 0 && !P->NextOperator && !P->is(TT_ConditionalExpr);
671	if ((!BreakBeforeOperator && !(HasTwoOperands && Style.AlignOperands)) \|\|
672	(!State.Stack.back().LastOperatorWrapped && BreakBeforeOperator))
673	State.Stack.back().NoLineBreakInOperand = true;
674	}
675
676	State.Column += Spaces;
677	if (Current.isNot(tok::comment) && Previous.is(tok::l_paren) &&
678	Previous.Previous &&
679	(Previous.Previous->isOneOf(tok::kw_if, tok::kw_for) \|\|
680	Previous.Previous->endsSequence(tok::kw_constexpr, tok::kw_if))) {
681	// Treat the condition inside an if as if it was a second function
682	// parameter, i.e. let nested calls have a continuation indent.
683	State.Stack.back().LastSpace = State.Column;
684	State.Stack.back().NestedBlockIndent = State.Column;
685	} else if (!Current.isOneOf(tok::comment, tok::caret) &&
686	((Previous.is(tok::comma) &&
687	!Previous.is(TT_OverloadedOperator)) \|\|
688	(Previous.is(tok::colon) && Previous.is(TT_ObjCMethodExpr)))) {
689	State.Stack.back().LastSpace = State.Column;
690	} else if (Previous.is(TT_CtorInitializerColon) &&
691	Style.BreakConstructorInitializers ==
692	FormatStyle::BCIS_AfterColon) {
693	State.Stack.back().Indent = State.Column;
694	State.Stack.back().LastSpace = State.Column;
695	} else if ((Previous.isOneOf(TT_BinaryOperator, TT_ConditionalExpr,
696	TT_CtorInitializerColon)) &&
697	((Previous.getPrecedence() != prec::Assignment &&
698	(Previous.isNot(tok::lessless) \|\| Previous.OperatorIndex != 0 \|\|
699	Previous.NextOperator)) \|\|
700	Current.StartsBinaryExpression)) {
701	// Indent relative to the RHS of the expression unless this is a simple
702	// assignment without binary expression on the RHS. Also indent relative to
703	// unary operators and the colons of constructor initializers.
704	if (Style.BreakBeforeBinaryOperators == FormatStyle::BOS_None)
705	State.Stack.back().LastSpace = State.Column;
706	} else if (Previous.is(TT_InheritanceColon)) {
707	State.Stack.back().Indent = State.Column;
708	State.Stack.back().LastSpace = State.Column;
709	} else if (Previous.opensScope()) {
710	// If a function has a trailing call, indent all parameters from the
711	// opening parenthesis. This avoids confusing indents like:
712	// OuterFunction(InnerFunctionCall( // break
713	// ParameterToInnerFunction)) // break
714	// .SecondInnerFunctionCall();
715	bool HasTrailingCall = false;
716	if (Previous.MatchingParen) {
717	const FormatToken *Next = Previous.MatchingParen->getNextNonComment();
718	HasTrailingCall = Next && Next->isMemberAccess();
719	}
720	if (HasTrailingCall && State.Stack.size() > 1 &&
721	State.Stack[State.Stack.size() - 2].CallContinuation == 0)
722	State.Stack.back().LastSpace = State.Column;
723	}
724	}
725
726	unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
727	bool DryRun) {
728	FormatToken &Current = *State.NextToken;
729	const FormatToken &Previous = *State.NextToken->Previous;
730
731	// Extra penalty that needs to be added because of the way certain line
732	// breaks are chosen.
733	unsigned Penalty = 0;
734
735	const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
736	const FormatToken *NextNonComment = Previous.getNextNonComment();
737	if (!NextNonComment)
738	NextNonComment = &Current;
739	// The first line break on any NestingLevel causes an extra penalty in order
740	// prefer similar line breaks.
741	if (!State.Stack.back().ContainsLineBreak)
742	Penalty += 15;
743	State.Stack.back().ContainsLineBreak = true;
744
745	Penalty += State.NextToken->SplitPenalty;
746
747	// Breaking before the first "<<" is generally not desirable if the LHS is
748	// short. Also always add the penalty if the LHS is split over multiple lines
749	// to avoid unnecessary line breaks that just work around this penalty.
750	if (NextNonComment->is(tok::lessless) &&
751	State.Stack.back().FirstLessLess == 0 &&
752	(State.Column <= Style.ColumnLimit / 3 \|\|
753	State.Stack.back().BreakBeforeParameter))
754	Penalty += Style.PenaltyBreakFirstLessLess;
755
756	State.Column = getNewLineColumn(State);
757
758	// Indent nested blocks relative to this column, unless in a very specific
759	// JavaScript special case where:
760	//
761	// var loooooong_name =
762	// function() {
763	// // code
764	// }
765	//
766	// is common and should be formatted like a free-standing function. The same
767	// goes for wrapping before the lambda return type arrow.
768	if (!Current.is(TT_LambdaArrow) &&
769	(Style.Language != FormatStyle::LK_JavaScript \|\|
770	Current.NestingLevel != 0 \|\| !PreviousNonComment \|\|
771	!PreviousNonComment->is(tok::equal) \|\|
772	!Current.isOneOf(Keywords.kw_async, Keywords.kw_function)))
773	State.Stack.back().NestedBlockIndent = State.Column;
774
775	if (NextNonComment->isMemberAccess()) {
776	if (State.Stack.back().CallContinuation == 0)
777	State.Stack.back().CallContinuation = State.Column;
778	} else if (NextNonComment->is(TT_SelectorName)) {
779	if (!State.Stack.back().ObjCSelectorNameFound) {
780	if (NextNonComment->LongestObjCSelectorName == 0) {
781	State.Stack.back().AlignColons = false;
782	} else {
783	State.Stack.back().ColonPos =
784	(shouldIndentWrappedSelectorName(Style, State.Line->Type)
785	? std::max(State.Stack.back().Indent,
786	State.FirstIndent + Style.ContinuationIndentWidth)
787	: State.Stack.back().Indent) +
788	std::max(NextNonComment->LongestObjCSelectorName,
789	NextNonComment->ColumnWidth);
790	}
791	} else if (State.Stack.back().AlignColons &&
792	State.Stack.back().ColonPos <= NextNonComment->ColumnWidth) {
793	State.Stack.back().ColonPos = State.Column + NextNonComment->ColumnWidth;
794	}
795	} else if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
796	PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral)) {
797	// FIXME: This is hacky, find a better way. The problem is that in an ObjC
798	// method expression, the block should be aligned to the line starting it,
799	// e.g.:
800	// [aaaaaaaaaaaaaaa aaaaaaaaa: \\ break for some reason
801	// ^(int *i) {
802	// // ...
803	// }];
804	// Thus, we set LastSpace of the next higher NestingLevel, to which we move
805	// when we consume all of the "}"'s FakeRParens at the "{".
806	if (State.Stack.size() > 1)
807	State.Stack[State.Stack.size() - 2].LastSpace =
808	std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) +
809	Style.ContinuationIndentWidth;
810	}
811
812	if ((PreviousNonComment &&
813	PreviousNonComment->isOneOf(tok::comma, tok::semi) &&
814	!State.Stack.back().AvoidBinPacking) \|\|
815	Previous.is(TT_BinaryOperator))
816	State.Stack.back().BreakBeforeParameter = false;
817	if (PreviousNonComment &&
818	PreviousNonComment->isOneOf(TT_TemplateCloser, TT_JavaAnnotation) &&
819	Current.NestingLevel == 0)
820	State.Stack.back().BreakBeforeParameter = false;
821	if (NextNonComment->is(tok::question) \|\|
822	(PreviousNonComment && PreviousNonComment->is(tok::question)))
823	State.Stack.back().BreakBeforeParameter = true;
824	if (Current.is(TT_BinaryOperator) && Current.CanBreakBefore)
825	State.Stack.back().BreakBeforeParameter = false;
826
827	if (!DryRun) {
828	unsigned MaxEmptyLinesToKeep = Style.MaxEmptyLinesToKeep + 1;
829	if (Current.is(tok::r_brace) && Current.MatchingParen &&
830	// Only strip trailing empty lines for l_braces that have children, i.e.
831	// for function expressions (lambdas, arrows, etc).
832	!Current.MatchingParen->Children.empty()) {
833	// lambdas and arrow functions are expressions, thus their r_brace is not
834	// on its own line, and thus not covered by UnwrappedLineFormatter's logic
835	// about removing empty lines on closing blocks. Special case them here.
836	MaxEmptyLinesToKeep = 1;
837	}
838	unsigned Newlines =
839	std::max(1u, std::min(Current.NewlinesBefore, MaxEmptyLinesToKeep));
840	bool ContinuePPDirective =
841	State.Line->InPPDirective && State.Line->Type != LT_ImportStatement;
842	Whitespaces.replaceWhitespace(Current, Newlines, State.Column, State.Column,
843	ContinuePPDirective);
844	}
845
846	if (!Current.isTrailingComment())
847	State.Stack.back().LastSpace = State.Column;
848	if (Current.is(tok::lessless))
849	// If we are breaking before a "<<", we always want to indent relative to
850	// RHS. This is necessary only for "<<", as we special-case it and don't
851	// always indent relative to the RHS.
852	State.Stack.back().LastSpace += 3; // 3 -> width of "<< ".
853
854	State.StartOfLineLevel = Current.NestingLevel;
855	State.LowestLevelOnLine = Current.NestingLevel;
856
857	// Any break on this level means that the parent level has been broken
858	// and we need to avoid bin packing there.
859	bool NestedBlockSpecialCase =
860	!Style.isCpp() && Current.is(tok::r_brace) && State.Stack.size() > 1 &&
861	State.Stack[State.Stack.size() - 2].NestedBlockInlined;
862	if (!NestedBlockSpecialCase)
863	for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i)
864	State.Stack[i].BreakBeforeParameter = true;
865
866	if (PreviousNonComment &&
867	!PreviousNonComment->isOneOf(tok::comma, tok::colon, tok::semi) &&
868	(PreviousNonComment->isNot(TT_TemplateCloser) \|\|
869	Current.NestingLevel != 0) &&
870	!PreviousNonComment->isOneOf(
871	TT_BinaryOperator, TT_FunctionAnnotationRParen, TT_JavaAnnotation,
872	TT_LeadingJavaAnnotation) &&
873	Current.isNot(TT_BinaryOperator) && !PreviousNonComment->opensScope())
874	State.Stack.back().BreakBeforeParameter = true;
875
876	// If we break after { or the [ of an array initializer, we should also break
877	// before the corresponding } or ].
878	if (PreviousNonComment &&
879	(PreviousNonComment->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) \|\|
880	opensProtoMessageField(*PreviousNonComment, Style)))
881	State.Stack.back().BreakBeforeClosingBrace = true;
882
883	if (State.Stack.back().AvoidBinPacking) {
884	// If we are breaking after '(', '{', '<', or this is the break after a ':'
885	// to start a member initializater list in a constructor, this should not
886	// be considered bin packing unless the relevant AllowAll option is false or
887	// this is a dict/object literal.
888	bool PreviousIsBreakingCtorInitializerColon =
889	Previous.is(TT_CtorInitializerColon) &&
890	Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon;
891	if (!(Previous.isOneOf(tok::l_paren, tok::l_brace, TT_BinaryOperator) \|\|
892	PreviousIsBreakingCtorInitializerColon) \|\|
893	(!Style.AllowAllParametersOfDeclarationOnNextLine &&
894	State.Line->MustBeDeclaration) \|\|
895	(!Style.AllowAllArgumentsOnNextLine &&
896	!State.Line->MustBeDeclaration) \|\|
897	(!Style.AllowAllConstructorInitializersOnNextLine &&
898	PreviousIsBreakingCtorInitializerColon) \|\|
899	Previous.is(TT_DictLiteral))
900	State.Stack.back().BreakBeforeParameter = true;
901
902	// If we are breaking after a ':' to start a member initializer list,
903	// and we allow all arguments on the next line, we should not break
904	// before the next parameter.
905	if (PreviousIsBreakingCtorInitializerColon &&
906	Style.AllowAllConstructorInitializersOnNextLine)
907	State.Stack.back().BreakBeforeParameter = false;
908	}
909
910	return Penalty;
911	}
912
913	unsigned ContinuationIndenter::getNewLineColumn(const LineState &State) {
914	if (!State.NextToken \|\| !State.NextToken->Previous)
915	return 0;
916	FormatToken &Current = *State.NextToken;
917	const FormatToken &Previous = *Current.Previous;
918	// If we are continuing an expression, we want to use the continuation indent.
919	unsigned ContinuationIndent =
920	std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) +
921	Style.ContinuationIndentWidth;
922	const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
923	const FormatToken *NextNonComment = Previous.getNextNonComment();
924	if (!NextNonComment)
925	NextNonComment = &Current;
926
927	// Java specific bits.
928	if (Style.Language == FormatStyle::LK_Java &&
929	Current.isOneOf(Keywords.kw_implements, Keywords.kw_extends))
930	return std::max(State.Stack.back().LastSpace,
931	State.Stack.back().Indent + Style.ContinuationIndentWidth);
932
933	if (NextNonComment->is(tok::l_brace) && NextNonComment->BlockKind == BK_Block)
934	return Current.NestingLevel == 0 ? State.FirstIndent
935	: State.Stack.back().Indent;
936	if ((Current.isOneOf(tok::r_brace, tok::r_square) \|\|
937	(Current.is(tok::greater) &&
938	(Style.Language == FormatStyle::LK_Proto \|\|
939	Style.Language == FormatStyle::LK_TextProto))) &&
940	State.Stack.size() > 1) {
941	if (Current.closesBlockOrBlockTypeList(Style))
942	return State.Stack[State.Stack.size() - 2].NestedBlockIndent;
943	if (Current.MatchingParen &&
944	Current.MatchingParen->BlockKind == BK_BracedInit)
945	return State.Stack[State.Stack.size() - 2].LastSpace;
946	return State.FirstIndent;
947	}
948	// Indent a closing parenthesis at the previous level if followed by a semi or
949	// opening brace. This allows indentations such as:
950	// foo(
951	// a,
952	// );
953	// function foo(
954	// a,
955	// ) {
956	// code(); //
957	// }
958	if (Current.is(tok::r_paren) && State.Stack.size() > 1 &&
959	(!Current.Next \|\| Current.Next->isOneOf(tok::semi, tok::l_brace)))
960	return State.Stack[State.Stack.size() - 2].LastSpace;
961	if (NextNonComment->is(TT_TemplateString) && NextNonComment->closesScope())
962	return State.Stack[State.Stack.size() - 2].LastSpace;
963	if (Current.is(tok::identifier) && Current.Next &&
964	(Current.Next->is(TT_DictLiteral) \|\|
965	((Style.Language == FormatStyle::LK_Proto \|\|
966	Style.Language == FormatStyle::LK_TextProto) &&
967	Current.Next->isOneOf(tok::less, tok::l_brace))))
968	return State.Stack.back().Indent;
969	if (NextNonComment->is(TT_ObjCStringLiteral) &&
970	State.StartOfStringLiteral != 0)
971	return State.StartOfStringLiteral - 1;
972	if (NextNonComment->isStringLiteral() && State.StartOfStringLiteral != 0)
973	return State.StartOfStringLiteral;
974	if (NextNonComment->is(tok::lessless) &&
975	State.Stack.back().FirstLessLess != 0)
976	return State.Stack.back().FirstLessLess;
977	if (NextNonComment->isMemberAccess()) {
978	if (State.Stack.back().CallContinuation == 0)
979	return ContinuationIndent;
980	return State.Stack.back().CallContinuation;
981	}
982	if (State.Stack.back().QuestionColumn != 0 &&
983	((NextNonComment->is(tok::colon) &&
984	NextNonComment->is(TT_ConditionalExpr)) \|\|
985	Previous.is(TT_ConditionalExpr)))
986	return State.Stack.back().QuestionColumn;
987	if (Previous.is(tok::comma) && State.Stack.back().VariablePos != 0)
988	return State.Stack.back().VariablePos;
989	if ((PreviousNonComment &&
990	(PreviousNonComment->ClosesTemplateDeclaration \|\|
991	PreviousNonComment->isOneOf(
992	TT_AttributeParen, TT_AttributeSquare, TT_FunctionAnnotationRParen,
993	TT_JavaAnnotation, TT_LeadingJavaAnnotation))) \|\|
994	(!Style.IndentWrappedFunctionNames &&
995	NextNonComment->isOneOf(tok::kw_operator, TT_FunctionDeclarationName)))
996	return std::max(State.Stack.back().LastSpace, State.Stack.back().Indent);
997	if (NextNonComment->is(TT_SelectorName)) {
998	if (!State.Stack.back().ObjCSelectorNameFound) {
999	unsigned MinIndent = State.Stack.back().Indent;
1000	if (shouldIndentWrappedSelectorName(Style, State.Line->Type))
1001	MinIndent = std::max(MinIndent,
1002	State.FirstIndent + Style.ContinuationIndentWidth);
1003	// If LongestObjCSelectorName is 0, we are indenting the first
1004	// part of an ObjC selector (or a selector component which is
1005	// not colon-aligned due to block formatting).
1006	//
1007	// Otherwise, we are indenting a subsequent part of an ObjC
1008	// selector which should be colon-aligned to the longest
1009	// component of the ObjC selector.
1010	//
1011	// In either case, we want to respect Style.IndentWrappedFunctionNames.
1012	return MinIndent +
1013	std::max(NextNonComment->LongestObjCSelectorName,
1014	NextNonComment->ColumnWidth) -
1015	NextNonComment->ColumnWidth;
1016	}
1017	if (!State.Stack.back().AlignColons)
1018	return State.Stack.back().Indent;
1019	if (State.Stack.back().ColonPos > NextNonComment->ColumnWidth)
1020	return State.Stack.back().ColonPos - NextNonComment->ColumnWidth;
1021	return State.Stack.back().Indent;
1022	}
1023	if (NextNonComment->is(tok::colon) && NextNonComment->is(TT_ObjCMethodExpr))
1024	return State.Stack.back().ColonPos;
1025	if (NextNonComment->is(TT_ArraySubscriptLSquare)) {
1026	if (State.Stack.back().StartOfArraySubscripts != 0)
1027	return State.Stack.back().StartOfArraySubscripts;
1028	return ContinuationIndent;
1029	}
1030
1031	// This ensure that we correctly format ObjC methods calls without inputs,
1032	// i.e. where the last element isn't selector like: [callee method];
1033	if (NextNonComment->is(tok::identifier) && NextNonComment->FakeRParens == 0 &&
1034	NextNonComment->Next && NextNonComment->Next->is(TT_ObjCMethodExpr))
1035	return State.Stack.back().Indent;
1036
1037	if (NextNonComment->isOneOf(TT_StartOfName, TT_PointerOrReference) \|\|
1038	Previous.isOneOf(tok::coloncolon, tok::equal, TT_JsTypeColon))
1039	return ContinuationIndent;
1040	if (PreviousNonComment && PreviousNonComment->is(tok::colon) &&
1041	PreviousNonComment->isOneOf(TT_ObjCMethodExpr, TT_DictLiteral))
1042	return ContinuationIndent;
1043	if (NextNonComment->is(TT_CtorInitializerComma))
1044	return State.Stack.back().Indent;
1045	if (PreviousNonComment && PreviousNonComment->is(TT_CtorInitializerColon) &&
1046	Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon)
1047	return State.Stack.back().Indent;
1048	if (PreviousNonComment && PreviousNonComment->is(TT_InheritanceColon) &&
1049	Style.BreakInheritanceList == FormatStyle::BILS_AfterColon)
1050	return State.Stack.back().Indent;
1051	if (NextNonComment->isOneOf(TT_CtorInitializerColon, TT_InheritanceColon,
1052	TT_InheritanceComma))
1053	return State.FirstIndent + Style.ConstructorInitializerIndentWidth;
1054	if (Previous.is(tok::r_paren) && !Current.isBinaryOperator() &&
1055	!Current.isOneOf(tok::colon, tok::comment))
1056	return ContinuationIndent;
1057	if (Current.is(TT_ProtoExtensionLSquare))
1058	return State.Stack.back().Indent;
1059	if (State.Stack.back().Indent == State.FirstIndent && PreviousNonComment &&
1060	PreviousNonComment->isNot(tok::r_brace))
1061	// Ensure that we fall back to the continuation indent width instead of
1062	// just flushing continuations left.
1063	return State.Stack.back().Indent + Style.ContinuationIndentWidth;
1064	return State.Stack.back().Indent;
1065	}
1066
1067	unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
1068	bool DryRun, bool Newline) {
1069	assert(State.Stack.size());
1070	const FormatToken &Current = *State.NextToken;
1071
1072	if (Current.isOneOf(tok::comma, TT_BinaryOperator))
1073	State.Stack.back().NoLineBreakInOperand = false;
1074	if (Current.is(TT_InheritanceColon))
1075	State.Stack.back().AvoidBinPacking = true;
1076	if (Current.is(tok::lessless) && Current.isNot(TT_OverloadedOperator)) {
1077	if (State.Stack.back().FirstLessLess == 0)
1078	State.Stack.back().FirstLessLess = State.Column;
1079	else
1080	State.Stack.back().LastOperatorWrapped = Newline;
1081	}
1082	if (Current.is(TT_BinaryOperator) && Current.isNot(tok::lessless))
1083	State.Stack.back().LastOperatorWrapped = Newline;
1084	if (Current.is(TT_ConditionalExpr) && Current.Previous &&
1085	!Current.Previous->is(TT_ConditionalExpr))
1086	State.Stack.back().LastOperatorWrapped = Newline;
1087	if (Current.is(TT_ArraySubscriptLSquare) &&
1088	State.Stack.back().StartOfArraySubscripts == 0)
1089	State.Stack.back().StartOfArraySubscripts = State.Column;
1090	if (Style.BreakBeforeTernaryOperators && Current.is(tok::question))
1091	State.Stack.back().QuestionColumn = State.Column;
1092	if (!Style.BreakBeforeTernaryOperators && Current.isNot(tok::colon)) {
1093	const FormatToken *Previous = Current.Previous;
1094	while (Previous && Previous->isTrailingComment())
1095	Previous = Previous->Previous;
1096	if (Previous && Previous->is(tok::question))
1097	State.Stack.back().QuestionColumn = State.Column;
1098	}
1099	if (!Current.opensScope() && !Current.closesScope() &&
1100	!Current.is(TT_PointerOrReference))
1101	State.LowestLevelOnLine =
1102	std::min(State.LowestLevelOnLine, Current.NestingLevel);
1103	if (Current.isMemberAccess())
1104	State.Stack.back().StartOfFunctionCall =
1105	!Current.NextOperator ? 0 : State.Column;
1106	if (Current.is(TT_SelectorName))
1107	State.Stack.back().ObjCSelectorNameFound = true;
1108	if (Current.is(TT_CtorInitializerColon) &&
1109	Style.BreakConstructorInitializers != FormatStyle::BCIS_AfterColon) {
1110	// Indent 2 from the column, so:
1111	// SomeClass::SomeClass()
1112	// : First(...), ...
1113	// Next(...)
1114	// ^ line up here.
1115	State.Stack.back().Indent =
1116	State.Column +
1117	(Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma
1118	? 0
1119	: 2);
1120	State.Stack.back().NestedBlockIndent = State.Stack.back().Indent;
1121	if (Style.ConstructorInitializerAllOnOneLineOrOnePerLine) {
1122	State.Stack.back().AvoidBinPacking = true;
1123	State.Stack.back().BreakBeforeParameter =
1124	!Style.AllowAllConstructorInitializersOnNextLine;
1125	} else {
1126	State.Stack.back().BreakBeforeParameter = false;
1127	}
1128	}
1129	if (Current.is(TT_CtorInitializerColon) &&
1130	Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon) {
1131	State.Stack.back().Indent =
1132	State.FirstIndent + Style.ConstructorInitializerIndentWidth;
1133	State.Stack.back().NestedBlockIndent = State.Stack.back().Indent;
1134	if (Style.ConstructorInitializerAllOnOneLineOrOnePerLine)
1135	State.Stack.back().AvoidBinPacking = true;
1136	}
1137	if (Current.is(TT_InheritanceColon))
1138	State.Stack.back().Indent =
1139	State.FirstIndent + Style.ConstructorInitializerIndentWidth;
1140	if (Current.isOneOf(TT_BinaryOperator, TT_ConditionalExpr) && Newline)
1141	State.Stack.back().NestedBlockIndent =
1142	State.Column + Current.ColumnWidth + 1;
1143	if (Current.isOneOf(TT_LambdaLSquare, TT_LambdaArrow))
1144	State.Stack.back().LastSpace = State.Column;
1145
1146	// Insert scopes created by fake parenthesis.
1147	const FormatToken *Previous = Current.getPreviousNonComment();
1148
1149	// Add special behavior to support a format commonly used for JavaScript
1150	// closures:
1151	// SomeFunction(function() {
1152	// foo();
1153	// bar();
1154	// }, a, b, c);
1155	if (Current.isNot(tok::comment) && Previous &&
1156	Previous->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&
1157	!Previous->is(TT_DictLiteral) && State.Stack.size() > 1 &&
1158	!State.Stack.back().HasMultipleNestedBlocks) {
1159	if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline)
1160	for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i)
1161	State.Stack[i].NoLineBreak = true;
1162	State.Stack[State.Stack.size() - 2].NestedBlockInlined = false;
1163	}
1164	if (Previous &&
1165	(Previous->isOneOf(tok::l_paren, tok::comma, tok::colon) \|\|
1166	Previous->isOneOf(TT_BinaryOperator, TT_ConditionalExpr)) &&
1167	!Previous->isOneOf(TT_DictLiteral, TT_ObjCMethodExpr)) {
1168	State.Stack.back().NestedBlockInlined =
1169	!Newline &&
1170	(Previous->isNot(tok::l_paren) \|\| Previous->ParameterCount > 1);
1171	}
1172
1173	moveStatePastFakeLParens(State, Newline);
1174	moveStatePastScopeCloser(State);
1175	bool AllowBreak = !State.Stack.back().NoLineBreak &&
1176	!State.Stack.back().NoLineBreakInOperand;
1177	moveStatePastScopeOpener(State, Newline);
1178	moveStatePastFakeRParens(State);
1179
1180	if (Current.is(TT_ObjCStringLiteral) && State.StartOfStringLiteral == 0)
1181	State.StartOfStringLiteral = State.Column + 1;
1182	if (Current.is(TT_CSharpStringLiteral) && State.StartOfStringLiteral == 0)
1183	State.StartOfStringLiteral = State.Column + 1;
1184	else if (Current.isStringLiteral() && State.StartOfStringLiteral == 0)
1185	State.StartOfStringLiteral = State.Column;
1186	else if (!Current.isOneOf(tok::comment, tok::identifier, tok::hash) &&
1187	!Current.isStringLiteral())
1188	State.StartOfStringLiteral = 0;
1189
1190	State.Column += Current.ColumnWidth;
1191	State.NextToken = State.NextToken->Next;
1192
1193	unsigned Penalty = handleEndOfLine(Current, State, DryRun, AllowBreak);
1194
1195	if (Current.Role)
1196	Current.Role->formatFromToken(State, this, DryRun);
1197	// If the previous has a special role, let it consume tokens as appropriate.
1198	// It is necessary to start at the previous token for the only implemented
1199	// role (comma separated list). That way, the decision whether or not to break
1200	// after the "{" is already done and both options are tried and evaluated.
1201	// FIXME: This is ugly, find a better way.
1202	if (Previous && Previous->Role)
1203	Penalty += Previous->Role->formatAfterToken(State, this, DryRun);
1204
1205	return Penalty;
1206	}
1207
1208	void ContinuationIndenter::moveStatePastFakeLParens(LineState &State,
1209	bool Newline) {
1210	const FormatToken &Current = *State.NextToken;
1211	const FormatToken *Previous = Current.getPreviousNonComment();
1212
1213	// Don't add extra indentation for the first fake parenthesis after
1214	// 'return', assignments or opening <({[. The indentation for these cases
1215	// is special cased.
1216	bool SkipFirstExtraIndent =
1217	(Previous && (Previous->opensScope() \|\|
1218	Previous->isOneOf(tok::semi, tok::kw_return) \|\|
1219	(Previous->getPrecedence() == prec::Assignment &&
1220	Style.AlignOperands) \|\|
1221	Previous->is(TT_ObjCMethodExpr)));
1222	for (SmallVectorImpl<prec::Level>::const_reverse_iterator
1223	I = Current.FakeLParens.rbegin(),
1224	E = Current.FakeLParens.rend();
1225	I != E; ++I) {
1226	ParenState NewParenState = State.Stack.back();
1227	NewParenState.Tok = nullptr;
1228	NewParenState.ContainsLineBreak = false;
1229	NewParenState.LastOperatorWrapped = true;
1230	NewParenState.NoLineBreak =
1231	NewParenState.NoLineBreak \|\| State.Stack.back().NoLineBreakInOperand;
1232
1233	// Don't propagate AvoidBinPacking into subexpressions of arg/param lists.
1234	if (*I > prec::Comma)
1235	NewParenState.AvoidBinPacking = false;
1236
1237	// Indent from 'LastSpace' unless these are fake parentheses encapsulating
1238	// a builder type call after 'return' or, if the alignment after opening
1239	// brackets is disabled.
1240	if (!Current.isTrailingComment() &&
1241	(Style.AlignOperands \|\| *I < prec::Assignment) &&
1242	(!Previous \|\| Previous->isNot(tok::kw_return) \|\|
1243	(Style.Language != FormatStyle::LK_Java && *I > 0)) &&
1244	(Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign \|\|
1245	*I != prec::Comma \|\| Current.NestingLevel == 0))
1246	NewParenState.Indent =
1247	std::max(std::max(State.Column, NewParenState.Indent),
1248	State.Stack.back().LastSpace);
1249
1250	// Do not indent relative to the fake parentheses inserted for "." or "->".
1251	// This is a special case to make the following to statements consistent:
1252	// OuterFunction(InnerFunctionCall( // break
1253	// ParameterToInnerFunction));
1254	// OuterFunction(SomeObject.InnerFunctionCall( // break
1255	// ParameterToInnerFunction));
1256	if (*I > prec::Unknown)
1257	NewParenState.LastSpace = std::max(NewParenState.LastSpace, State.Column);
1258	if (*I != prec::Conditional && !Current.is(TT_UnaryOperator) &&
1259	Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign)
1260	NewParenState.StartOfFunctionCall = State.Column;
1261
1262	// Always indent conditional expressions. Never indent expression where
1263	// the 'operator' is ',', ';' or an assignment (i.e. *I <=
1264	// prec::Assignment) as those have different indentation rules. Indent
1265	// other expression, unless the indentation needs to be skipped.
1266	if (*I == prec::Conditional \|\|
1267	(!SkipFirstExtraIndent && *I > prec::Assignment &&
1268	!Current.isTrailingComment()))
1269	NewParenState.Indent += Style.ContinuationIndentWidth;
1270	if ((Previous && !Previous->opensScope()) \|\| *I != prec::Comma)
1271	NewParenState.BreakBeforeParameter = false;
1272	State.Stack.push_back(NewParenState);
1273	SkipFirstExtraIndent = false;
1274	}
1275	}
1276
1277	void ContinuationIndenter::moveStatePastFakeRParens(LineState &State) {
1278	for (unsigned i = 0, e = State.NextToken->FakeRParens; i != e; ++i) {
1279	unsigned VariablePos = State.Stack.back().VariablePos;
1280	if (State.Stack.size() == 1) {
1281	// Do not pop the last element.
1282	break;
1283	}
1284	State.Stack.pop_back();
1285	State.Stack.back().VariablePos = VariablePos;
1286	}
1287	}
1288
1289	void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
1290	bool Newline) {
1291	const FormatToken &Current = *State.NextToken;
1292	if (!Current.opensScope())
1293	return;
1294
1295	if (Current.MatchingParen && Current.BlockKind == BK_Block) {
1296	moveStateToNewBlock(State);
1297	return;
1298	}
1299
1300	unsigned NewIndent;
1301	unsigned LastSpace = State.Stack.back().LastSpace;
1302	bool AvoidBinPacking;
1303	bool BreakBeforeParameter = false;
1304	unsigned NestedBlockIndent = std::max(State.Stack.back().StartOfFunctionCall,
1305	State.Stack.back().NestedBlockIndent);
1306	if (Current.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) \|\|
1307	opensProtoMessageField(Current, Style)) {
1308	if (Current.opensBlockOrBlockTypeList(Style)) {
1309	NewIndent = Style.IndentWidth +
1310	std::min(State.Column, State.Stack.back().NestedBlockIndent);
1311	} else {
1312	NewIndent = State.Stack.back().LastSpace + Style.ContinuationIndentWidth;
1313	}
1314	const FormatToken *NextNoComment = Current.getNextNonComment();
1315	bool EndsInComma = Current.MatchingParen &&
1316	Current.MatchingParen->Previous &&
1317	Current.MatchingParen->Previous->is(tok::comma);
1318	AvoidBinPacking = EndsInComma \|\| Current.is(TT_DictLiteral) \|\|
1319	Style.Language == FormatStyle::LK_Proto \|\|
1320	Style.Language == FormatStyle::LK_TextProto \|\|
1321	!Style.BinPackArguments \|\|
1322	(NextNoComment &&
1323	NextNoComment->isOneOf(TT_DesignatedInitializerPeriod,
1324	TT_DesignatedInitializerLSquare));
1325	BreakBeforeParameter = EndsInComma;
1326	if (Current.ParameterCount > 1)
1327	NestedBlockIndent = std::max(NestedBlockIndent, State.Column + 1);
1328	} else {
1329	NewIndent = Style.ContinuationIndentWidth +
1330	std::max(State.Stack.back().LastSpace,
1331	State.Stack.back().StartOfFunctionCall);
1332
1333	// Ensure that different different brackets force relative alignment, e.g.:
1334	// void SomeFunction(vector< // break
1335	// int> v);
1336	// FIXME: We likely want to do this for more combinations of brackets.
1337	if (Current.is(tok::less) && Current.ParentBracket == tok::l_paren) {
1338	NewIndent = std::max(NewIndent, State.Stack.back().Indent);
1339	LastSpace = std::max(LastSpace, State.Stack.back().Indent);
1340	}
1341
1342	bool EndsInComma =
1343	Current.MatchingParen &&
1344	Current.MatchingParen->getPreviousNonComment() &&
1345	Current.MatchingParen->getPreviousNonComment()->is(tok::comma);
1346
1347	// If ObjCBinPackProtocolList is unspecified, fall back to BinPackParameters
1348	// for backwards compatibility.
1349	bool ObjCBinPackProtocolList =
1350	(Style.ObjCBinPackProtocolList == FormatStyle::BPS_Auto &&
1351	Style.BinPackParameters) \|\|
1352	Style.ObjCBinPackProtocolList == FormatStyle::BPS_Always;
1353
1354	bool BinPackDeclaration =
1355	(State.Line->Type != LT_ObjCDecl && Style.BinPackParameters) \|\|
1356	(State.Line->Type == LT_ObjCDecl && ObjCBinPackProtocolList);
1357
1358	AvoidBinPacking =
1359	(Style.Language == FormatStyle::LK_JavaScript && EndsInComma) \|\|
1360	(State.Line->MustBeDeclaration && !BinPackDeclaration) \|\|
1361	(!State.Line->MustBeDeclaration && !Style.BinPackArguments) \|\|
1362	(Style.ExperimentalAutoDetectBinPacking &&
1363	(Current.PackingKind == PPK_OnePerLine \|\|
1364	(!BinPackInconclusiveFunctions &&
1365	Current.PackingKind == PPK_Inconclusive)));
1366
1367	if (Current.is(TT_ObjCMethodExpr) && Current.MatchingParen) {
1368	if (Style.ColumnLimit) {
1369	// If this '[' opens an ObjC call, determine whether all parameters fit
1370	// into one line and put one per line if they don't.
1371	if (getLengthToMatchingParen(Current, State.Stack) + State.Column >
1372	getColumnLimit(State))
1373	BreakBeforeParameter = true;
1374	} else {
1375	// For ColumnLimit = 0, we have to figure out whether there is or has to
1376	// be a line break within this call.
1377	for (const FormatToken *Tok = &Current;
1378	Tok && Tok != Current.MatchingParen; Tok = Tok->Next) {
1379	if (Tok->MustBreakBefore \|\|
1380	(Tok->CanBreakBefore && Tok->NewlinesBefore > 0)) {
1381	BreakBeforeParameter = true;
1382	break;
1383	}
1384	}
1385	}
1386	}
1387
1388	if (Style.Language == FormatStyle::LK_JavaScript && EndsInComma)
1389	BreakBeforeParameter = true;
1390	}
1391	// Generally inherit NoLineBreak from the current scope to nested scope.
1392	// However, don't do this for non-empty nested blocks, dict literals and
1393	// array literals as these follow different indentation rules.
1394	bool NoLineBreak =
1395	Current.Children.empty() &&
1396	!Current.isOneOf(TT_DictLiteral, TT_ArrayInitializerLSquare) &&
1397	(State.Stack.back().NoLineBreak \|\|
1398	State.Stack.back().NoLineBreakInOperand \|\|
1399	(Current.is(TT_TemplateOpener) &&
1400	State.Stack.back().ContainsUnwrappedBuilder));
1401	State.Stack.push_back(
1402	ParenState(&Current, NewIndent, LastSpace, AvoidBinPacking, NoLineBreak));
1403	State.Stack.back().NestedBlockIndent = NestedBlockIndent;
1404	State.Stack.back().BreakBeforeParameter = BreakBeforeParameter;
1405	State.Stack.back().HasMultipleNestedBlocks = Current.BlockParameterCount > 1;
1406	State.Stack.back().IsInsideObjCArrayLiteral =
1407	Current.is(TT_ArrayInitializerLSquare) && Current.Previous &&
1408	Current.Previous->is(tok::at);
1409	}
1410
1411	void ContinuationIndenter::moveStatePastScopeCloser(LineState &State) {
1412	const FormatToken &Current = *State.NextToken;
1413	if (!Current.closesScope())
1414	return;
1415
1416	// If we encounter a closing ), ], } or >, we can remove a level from our
1417	// stacks.
1418	if (State.Stack.size() > 1 &&
1419	(Current.isOneOf(tok::r_paren, tok::r_square, TT_TemplateString) \|\|
1420	(Current.is(tok::r_brace) && State.NextToken != State.Line->First) \|\|
1421	State.NextToken->is(TT_TemplateCloser) \|\|
1422	(Current.is(tok::greater) && Current.is(TT_DictLiteral))))
1423	State.Stack.pop_back();
1424
1425	// Reevaluate whether ObjC message arguments fit into one line.
1426	// If a receiver spans multiple lines, e.g.:
1427	// [[object block:^{
1428	// return 42;
1429	// }] a:42 b:42];
1430	// BreakBeforeParameter is calculated based on an incorrect assumption
1431	// (it is checked whether the whole expression fits into one line without
1432	// considering a line break inside a message receiver).
1433	// We check whether arguements fit after receiver scope closer (into the same
1434	// line).
1435	if (State.Stack.back().BreakBeforeParameter && Current.MatchingParen &&
1436	Current.MatchingParen->Previous) {
1437	const FormatToken &CurrentScopeOpener = *Current.MatchingParen->Previous;
1438	if (CurrentScopeOpener.is(TT_ObjCMethodExpr) &&
1439	CurrentScopeOpener.MatchingParen) {
1440	int NecessarySpaceInLine =
1441	getLengthToMatchingParen(CurrentScopeOpener, State.Stack) +
1442	CurrentScopeOpener.TotalLength - Current.TotalLength - 1;
1443	if (State.Column + Current.ColumnWidth + NecessarySpaceInLine <=
1444	Style.ColumnLimit)
1445	State.Stack.back().BreakBeforeParameter = false;
1446	}
1447	}
1448
1449	if (Current.is(tok::r_square)) {
1450	// If this ends the array subscript expr, reset the corresponding value.
1451	const FormatToken *NextNonComment = Current.getNextNonComment();
1452	if (NextNonComment && NextNonComment->isNot(tok::l_square))
1453	State.Stack.back().StartOfArraySubscripts = 0;
1454	}
1455	}
1456
1457	void ContinuationIndenter::moveStateToNewBlock(LineState &State) {
1458	unsigned NestedBlockIndent = State.Stack.back().NestedBlockIndent;
1459	// ObjC block sometimes follow special indentation rules.
1460	unsigned NewIndent =
1461	NestedBlockIndent + (State.NextToken->is(TT_ObjCBlockLBrace)
1462	? Style.ObjCBlockIndentWidth
1463	: Style.IndentWidth);
1464	State.Stack.push_back(ParenState(State.NextToken, NewIndent,
1465	State.Stack.back().LastSpace,
1466	/AvoidBinPacking=/true,
1467	/NoLineBreak=/false));
1468	State.Stack.back().NestedBlockIndent = NestedBlockIndent;
1469	State.Stack.back().BreakBeforeParameter = true;
1470	}
1471
1472	static unsigned getLastLineEndColumn(StringRef Text, unsigned StartColumn,
1473	unsigned TabWidth,
1474	encoding::Encoding Encoding) {
1475	size_t LastNewlinePos = Text.find_last_of("\n");
1476	if (LastNewlinePos == StringRef::npos) {
1477	return StartColumn +
1478	encoding::columnWidthWithTabs(Text, StartColumn, TabWidth, Encoding);
1479	} else {
1480	return encoding::columnWidthWithTabs(Text.substr(LastNewlinePos),
1481	/StartColumn=/0, TabWidth, Encoding);
1482	}
1483	}
1484
1485	unsigned ContinuationIndenter::reformatRawStringLiteral(
1486	const FormatToken &Current, LineState &State,
1487	const FormatStyle &RawStringStyle, bool DryRun) {
1488	unsigned StartColumn = State.Column - Current.ColumnWidth;
1489	StringRef OldDelimiter = *getRawStringDelimiter(Current.TokenText);
1490	StringRef NewDelimiter =
1491	getCanonicalRawStringDelimiter(Style, RawStringStyle.Language);
1492	if (NewDelimiter.empty() \|\| OldDelimiter.empty())
1493	NewDelimiter = OldDelimiter;
1494	// The text of a raw string is between the leading 'R"delimiter(' and the
1495	// trailing 'delimiter)"'.
1496	unsigned OldPrefixSize = 3 + OldDelimiter.size();
1497	unsigned OldSuffixSize = 2 + OldDelimiter.size();
1498	// We create a virtual text environment which expects a null-terminated
1499	// string, so we cannot use StringRef.
1500	std::string RawText =
1501	Current.TokenText.substr(OldPrefixSize).drop_back(OldSuffixSize);
1502	if (NewDelimiter != OldDelimiter) {
1503	// Don't update to the canonical delimiter 'deli' if ')deli"' occurs in the
1504	// raw string.
1505	std::string CanonicalDelimiterSuffix = (")" + NewDelimiter + "\"").str();
1506	if (StringRef(RawText).contains(CanonicalDelimiterSuffix))
1507	NewDelimiter = OldDelimiter;
1508	}
1509
1510	unsigned NewPrefixSize = 3 + NewDelimiter.size();
1511	unsigned NewSuffixSize = 2 + NewDelimiter.size();
1512
1513	// The first start column is the column the raw text starts after formatting.
1514	unsigned FirstStartColumn = StartColumn + NewPrefixSize;
1515
1516	// The next start column is the intended indentation a line break inside
1517	// the raw string at level 0. It is determined by the following rules:
1518	// - if the content starts on newline, it is one level more than the current
1519	// indent, and
1520	// - if the content does not start on a newline, it is the first start
1521	// column.
1522	// These rules have the advantage that the formatted content both does not
1523	// violate the rectangle rule and visually flows within the surrounding
1524	// source.
1525	bool ContentStartsOnNewline = Current.TokenText[OldPrefixSize] == '\n';
1526	// If this token is the last parameter (checked by looking if it's followed by
1527	// `)`, the base the indent off the line's nested block indent. Otherwise,
1528	// base the indent off the arguments indent, so we can achieve:
1529	// fffffffffff(1, 2, 3, R"pb(
1530	// key1: 1 #
1531	// key2: 2)pb");
1532	//
1533	// fffffffffff(1, 2, 3,
1534	// R"pb(
1535	// key1: 1 #
1536	// key2: 2
1537	// )pb",
1538	// 5);
1539	unsigned CurrentIndent = (Current.Next && Current.Next->is(tok::r_paren))
1540	? State.Stack.back().NestedBlockIndent
1541	: State.Stack.back().Indent;
1542	unsigned NextStartColumn = ContentStartsOnNewline
1543	? CurrentIndent + Style.IndentWidth
1544	: FirstStartColumn;
1545
1546	// The last start column is the column the raw string suffix starts if it is
1547	// put on a newline.
1548	// The last start column is the intended indentation of the raw string postfix
1549	// if it is put on a newline. It is determined by the following rules:
1550	// - if the raw string prefix starts on a newline, it is the column where
1551	// that raw string prefix starts, and
1552	// - if the raw string prefix does not start on a newline, it is the current
1553	// indent.
1554	unsigned LastStartColumn =
1555	Current.NewlinesBefore ? FirstStartColumn - NewPrefixSize : CurrentIndent;
1556
1557	std::pair<tooling::Replacements, unsigned> Fixes = internal::reformat(
1558	RawStringStyle, RawText, {tooling::Range(0, RawText.size())},
1559	FirstStartColumn, NextStartColumn, LastStartColumn, "<stdin>",
1560	/Status=/nullptr);
1561
1562	auto NewCode = applyAllReplacements(RawText, Fixes.first);
1563	tooling::Replacements NoFixes;
1564	if (!NewCode) {
1565	return addMultilineToken(Current, State);
1566	}
1567	if (!DryRun) {
1568	if (NewDelimiter != OldDelimiter) {
1569	// In 'R"delimiter(...', the delimiter starts 2 characters after the start
1570	// of the token.
1571	SourceLocation PrefixDelimiterStart =
1572	Current.Tok.getLocation().getLocWithOffset(2);
1573	auto PrefixErr = Whitespaces.addReplacement(tooling::Replacement(
1574	SourceMgr, PrefixDelimiterStart, OldDelimiter.size(), NewDelimiter));
1575	if (PrefixErr) {
1576	llvm::errs()
1577	<< "Failed to update the prefix delimiter of a raw string: "
1578	<< llvm::toString(std::move(PrefixErr)) << "\n";
1579	}
1580	// In 'R"delimiter(...)delimiter"', the suffix delimiter starts at
1581	// position length - 1 - \|delimiter\|.
1582	SourceLocation SuffixDelimiterStart =
1583	Current.Tok.getLocation().getLocWithOffset(Current.TokenText.size() -
1584	1 - OldDelimiter.size());
1585	auto SuffixErr = Whitespaces.addReplacement(tooling::Replacement(
1586	SourceMgr, SuffixDelimiterStart, OldDelimiter.size(), NewDelimiter));
1587	if (SuffixErr) {
1588	llvm::errs()
1589	<< "Failed to update the suffix delimiter of a raw string: "
1590	<< llvm::toString(std::move(SuffixErr)) << "\n";
1591	}
1592	}
1593	SourceLocation OriginLoc =
1594	Current.Tok.getLocation().getLocWithOffset(OldPrefixSize);
1595	for (const tooling::Replacement &Fix : Fixes.first) {
1596	auto Err = Whitespaces.addReplacement(tooling::Replacement(
1597	SourceMgr, OriginLoc.getLocWithOffset(Fix.getOffset()),
1598	Fix.getLength(), Fix.getReplacementText()));
1599	if (Err) {
1600	llvm::errs() << "Failed to reformat raw string: "
1601	<< llvm::toString(std::move(Err)) << "\n";
1602	}
1603	}
1604	}
1605	unsigned RawLastLineEndColumn = getLastLineEndColumn(
1606	*NewCode, FirstStartColumn, Style.TabWidth, Encoding);
1607	State.Column = RawLastLineEndColumn + NewSuffixSize;
1608	// Since we're updating the column to after the raw string literal here, we
1609	// have to manually add the penalty for the prefix R"delim( over the column
1610	// limit.
1611	unsigned PrefixExcessCharacters =
1612	StartColumn + NewPrefixSize > Style.ColumnLimit
1613	? StartColumn + NewPrefixSize - Style.ColumnLimit
1614	: 0;
1615	bool IsMultiline =
1616	ContentStartsOnNewline \|\| (NewCode->find('\n') != std::string::npos);
1617	if (IsMultiline) {
1618	// Break before further function parameters on all levels.
1619	for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
1620	State.Stack[i].BreakBeforeParameter = true;
1621	}
1622	return Fixes.second + PrefixExcessCharacters * Style.PenaltyExcessCharacter;
1623	}
1624
1625	unsigned ContinuationIndenter::addMultilineToken(const FormatToken &Current,
1626	LineState &State) {
1627	// Break before further function parameters on all levels.
1628	for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
1629	State.Stack[i].BreakBeforeParameter = true;
1630
1631	unsigned ColumnsUsed = State.Column;
1632	// We can only affect layout of the first and the last line, so the penalty
1633	// for all other lines is constant, and we ignore it.
1634	State.Column = Current.LastLineColumnWidth;
1635
1636	if (ColumnsUsed > getColumnLimit(State))
1637	return Style.PenaltyExcessCharacter * (ColumnsUsed - getColumnLimit(State));
1638	return 0;
1639	}
1640
1641	unsigned ContinuationIndenter::handleEndOfLine(const FormatToken &Current,
1642	LineState &State, bool DryRun,
1643	bool AllowBreak) {
1644	unsigned Penalty = 0;
1645	// Compute the raw string style to use in case this is a raw string literal
1646	// that can be reformatted.
1647	auto RawStringStyle = getRawStringStyle(Current, State);
1648	if (RawStringStyle && !Current.Finalized) {
1649	Penalty = reformatRawStringLiteral(Current, State, *RawStringStyle, DryRun);
1650	} else if (Current.IsMultiline && Current.isNot(TT_BlockComment)) {
1651	// Don't break multi-line tokens other than block comments and raw string
1652	// literals. Instead, just update the state.
1653	Penalty = addMultilineToken(Current, State);
1654	} else if (State.Line->Type != LT_ImportStatement) {
1655	// We generally don't break import statements.
1656	LineState OriginalState = State;
1657
1658	// Whether we force the reflowing algorithm to stay strictly within the
1659	// column limit.
1660	bool Strict = false;
1661	// Whether the first non-strict attempt at reflowing did intentionally
1662	// exceed the column limit.
1663	bool Exceeded = false;
1664	std::tie(Penalty, Exceeded) = breakProtrudingToken(
1665	Current, State, AllowBreak, /DryRun=/true, Strict);
1666	if (Exceeded) {
1667	// If non-strict reflowing exceeds the column limit, try whether strict
1668	// reflowing leads to an overall lower penalty.
1669	LineState StrictState = OriginalState;
1670	unsigned StrictPenalty =
1671	breakProtrudingToken(Current, StrictState, AllowBreak,
1672	/DryRun=/true, /Strict=/true)
1673	.first;
1674	Strict = StrictPenalty <= Penalty;
1675	if (Strict) {
1676	Penalty = StrictPenalty;
1677	State = StrictState;
1678	}
1679	}
1680	if (!DryRun) {
1681	// If we're not in dry-run mode, apply the changes with the decision on
1682	// strictness made above.
1683	breakProtrudingToken(Current, OriginalState, AllowBreak, /DryRun=/false,
1684	Strict);
1685	}
1686	}
1687	if (State.Column > getColumnLimit(State)) {
1688	unsigned ExcessCharacters = State.Column - getColumnLimit(State);
1689	Penalty += Style.PenaltyExcessCharacter * ExcessCharacters;
1690	}
1691	return Penalty;
1692	}
1693
1694	// Returns the enclosing function name of a token, or the empty string if not
1695	// found.
1696	static StringRef getEnclosingFunctionName(const FormatToken &Current) {
1697	// Look for: 'function(' or 'function<templates>(' before Current.
1698	auto Tok = Current.getPreviousNonComment();
1699	if (!Tok \|\| !Tok->is(tok::l_paren))
1700	return "";
1701	Tok = Tok->getPreviousNonComment();
1702	if (!Tok)
1703	return "";
1704	if (Tok->is(TT_TemplateCloser)) {
1705	Tok = Tok->MatchingParen;
1706	if (Tok)
1707	Tok = Tok->getPreviousNonComment();
1708	}
1709	if (!Tok \|\| !Tok->is(tok::identifier))
1710	return "";
1711	return Tok->TokenText;
1712	}
1713
1714	llvm::Optional<FormatStyle>
1715	ContinuationIndenter::getRawStringStyle(const FormatToken &Current,
1716	const LineState &State) {
1717	if (!Current.isStringLiteral())
1718	return None;
1719	auto Delimiter = getRawStringDelimiter(Current.TokenText);
1720	if (!Delimiter)
1721	return None;
1722	auto RawStringStyle = RawStringFormats.getDelimiterStyle(*Delimiter);
1723	if (!RawStringStyle && Delimiter->empty())
1724	RawStringStyle = RawStringFormats.getEnclosingFunctionStyle(
1725	getEnclosingFunctionName(Current));
1726	if (!RawStringStyle)
1727	return None;
1728	RawStringStyle->ColumnLimit = getColumnLimit(State);
1729	return RawStringStyle;
1730	}
1731
1732	std::unique_ptr<BreakableToken>
1733	ContinuationIndenter::createBreakableToken(const FormatToken &Current,
1734	LineState &State, bool AllowBreak) {
1735	unsigned StartColumn = State.Column - Current.ColumnWidth;
1736	if (Current.isStringLiteral()) {
1737	// FIXME: String literal breaking is currently disabled for C#,Java and
1738	// JavaScript, as it requires strings to be merged using "+" which we
1739	// don't support.
1740	if (Style.Language == FormatStyle::LK_Java \|\|
1741	Style.Language == FormatStyle::LK_JavaScript \|\| Style.isCSharp() \|\|
1742	!Style.BreakStringLiterals \|\| !AllowBreak)
1743	return nullptr;
1744
1745	// Don't break string literals inside preprocessor directives (except for
1746	// #define directives, as their contents are stored in separate lines and
1747	// are not affected by this check).
1748	// This way we avoid breaking code with line directives and unknown
1749	// preprocessor directives that contain long string literals.
1750	if (State.Line->Type == LT_PreprocessorDirective)
1751	return nullptr;
1752	// Exempts unterminated string literals from line breaking. The user will
1753	// likely want to terminate the string before any line breaking is done.
1754	if (Current.IsUnterminatedLiteral)
1755	return nullptr;
1756	// Don't break string literals inside Objective-C array literals (doing so
1757	// raises the warning -Wobjc-string-concatenation).
1758	if (State.Stack.back().IsInsideObjCArrayLiteral) {
1759	return nullptr;
1760	}
1761
1762	StringRef Text = Current.TokenText;
1763	StringRef Prefix;
1764	StringRef Postfix;
1765	// FIXME: Handle whitespace between '_T', '(', '"..."', and ')'.
1766	// FIXME: Store Prefix and Suffix (or PrefixLength and SuffixLength to
1767	// reduce the overhead) for each FormatToken, which is a string, so that we
1768	// don't run multiple checks here on the hot path.
1769	if ((Text.endswith(Postfix = "\"") &&
1770	(Text.startswith(Prefix = "@\"") \|\| Text.startswith(Prefix = "\"") \|\|
1771	Text.startswith(Prefix = "u\"") \|\| Text.startswith(Prefix = "U\"") \|\|
1772	Text.startswith(Prefix = "u8\"") \|\|
1773	Text.startswith(Prefix = "L\""))) \|\|
1774	(Text.startswith(Prefix = "_T(\"") && Text.endswith(Postfix = "\")"))) {
1775	// We need this to address the case where there is an unbreakable tail
1776	// only if certain other formatting decisions have been taken. The
1777	// UnbreakableTailLength of Current is an overapproximation is that case
1778	// and we need to be correct here.
1779	unsigned UnbreakableTailLength = (State.NextToken && canBreak(State))
1780	? 0
1781	: Current.UnbreakableTailLength;
1782	return llvm::make_unique<BreakableStringLiteral>(
1783	Current, StartColumn, Prefix, Postfix, UnbreakableTailLength,
1784	State.Line->InPPDirective, Encoding, Style);
1785	}
1786	} else if (Current.is(TT_BlockComment)) {
1787	if (!Style.ReflowComments \|\|
1788	// If a comment token switches formatting, like
1789	// /* clang-format on */, we don't want to break it further,
1790	// but we may still want to adjust its indentation.
1791	switchesFormatting(Current)) {
1792	return nullptr;
1793	}
1794	return llvm::make_unique<BreakableBlockComment>(
1795	Current, StartColumn, Current.OriginalColumn, !Current.Previous,
1796	State.Line->InPPDirective, Encoding, Style);
1797	} else if (Current.is(TT_LineComment) &&
1798	(Current.Previous == nullptr \|\|
1799	Current.Previous->isNot(TT_ImplicitStringLiteral))) {
1800	if (!Style.ReflowComments \|\|
1801	CommentPragmasRegex.match(Current.TokenText.substr(2)) \|\|
1802	switchesFormatting(Current))
1803	return nullptr;
1804	return llvm::make_unique<BreakableLineCommentSection>(
1805	Current, StartColumn, Current.OriginalColumn, !Current.Previous,
1806	/InPPDirective=/false, Encoding, Style);
1807	}
1808	return nullptr;
1809	}
1810
1811	std::pair<unsigned, bool>
1812	ContinuationIndenter::breakProtrudingToken(const FormatToken &Current,
1813	LineState &State, bool AllowBreak,
1814	bool DryRun, bool Strict) {
1815	std::unique_ptr<const BreakableToken> Token =
1816	createBreakableToken(Current, State, AllowBreak);
1817	if (!Token)
1818	return {0, false};
1819	getLineCount() > 0", "/home/seafit/code_projects/clang_source/clang/lib/Format/ContinuationIndenter.cpp", 1819, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Token->getLineCount() > 0);
1820	unsigned ColumnLimit = getColumnLimit(State);
1821	if (Current.is(TT_LineComment)) {
1822	// We don't insert backslashes when breaking line comments.
1823	ColumnLimit = Style.ColumnLimit;
1824	}
1825	if (Current.UnbreakableTailLength >= ColumnLimit)
1826	return {0, false};
1827	// ColumnWidth was already accounted into State.Column before calling
1828	// breakProtrudingToken.
1829	unsigned StartColumn = State.Column - Current.ColumnWidth;
1830	unsigned NewBreakPenalty = Current.isStringLiteral()
1831	? Style.PenaltyBreakString
1832	: Style.PenaltyBreakComment;
1833	// Stores whether we intentionally decide to let a line exceed the column
1834	// limit.
1835	bool Exceeded = false;
1836	// Stores whether we introduce a break anywhere in the token.
1837	bool BreakInserted = Token->introducesBreakBeforeToken();
1838	// Store whether we inserted a new line break at the end of the previous
1839	// logical line.
1840	bool NewBreakBefore = false;
1841	// We use a conservative reflowing strategy. Reflow starts after a line is
1842	// broken or the corresponding whitespace compressed. Reflow ends as soon as a
1843	// line that doesn't get reflown with the previous line is reached.
1844	bool Reflow = false;
1845	// Keep track of where we are in the token:
1846	// Where we are in the content of the current logical line.
1847	unsigned TailOffset = 0;
1848	// The column number we're currently at.
1849	unsigned ContentStartColumn =
1850	Token->getContentStartColumn(0, /Break=/false);
1851	// The number of columns left in the current logical line after TailOffset.
1852	unsigned RemainingTokenColumns =
1853	Token->getRemainingLength(0, TailOffset, ContentStartColumn);
1854	// Adapt the start of the token, for example indent.
1855	if (!DryRun)
1856	Token->adaptStartOfLine(0, Whitespaces);
1857
1858	unsigned ContentIndent = 0;
1859	unsigned Penalty = 0;
1860	LLVM_DEBUG(llvm::dbgs() << "Breaking protruding token at column "
1861	<< StartColumn << ".\n");
1862	for (unsigned LineIndex = 0, EndIndex = Token->getLineCount();
1863	LineIndex != EndIndex; ++LineIndex) {
1864	LLVM_DEBUG(llvm::dbgs()
1865	<< " Line: " << LineIndex << " (Reflow: " << Reflow << ")\n");
1866	NewBreakBefore = false;
1867	// If we did reflow the previous line, we'll try reflowing again. Otherwise
1868	// we'll start reflowing if the current line is broken or whitespace is
1869	// compressed.
1870	bool TryReflow = Reflow;
1871	// Break the current token until we can fit the rest of the line.
1872	while (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
1873	LLVM_DEBUG(llvm::dbgs() << " Over limit, need: "
1874	<< (ContentStartColumn + RemainingTokenColumns)
1875	<< ", space: " << ColumnLimit
1876	<< ", reflown prefix: " << ContentStartColumn
1877	<< ", offset in line: " << TailOffset << "\n");
1878	// If the current token doesn't fit, find the latest possible split in the
1879	// current line so that breaking at it will be under the column limit.
1880	// FIXME: Use the earliest possible split while reflowing to correctly
1881	// compress whitespace within a line.
1882	BreakableToken::Split Split =
1883	Token->getSplit(LineIndex, TailOffset, ColumnLimit,
1884	ContentStartColumn, CommentPragmasRegex);
1885	if (Split.first == StringRef::npos) {
1886	// No break opportunity - update the penalty and continue with the next
1887	// logical line.
1888	if (LineIndex < EndIndex - 1)
1889	// The last line's penalty is handled in addNextStateToQueue() or when
1890	// calling replaceWhitespaceAfterLastLine below.
1891	Penalty += Style.PenaltyExcessCharacter *
1892	(ContentStartColumn + RemainingTokenColumns - ColumnLimit);
1893	LLVM_DEBUG(llvm::dbgs() << " No break opportunity.\n");
1894	break;
1895	}
1896	assert(Split.first != 0);
1897
1898	if (Token->supportsReflow()) {
1899	// Check whether the next natural split point after the current one can
1900	// still fit the line, either because we can compress away whitespace,
1901	// or because the penalty the excess characters introduce is lower than
1902	// the break penalty.
1903	// We only do this for tokens that support reflowing, and thus allow us
1904	// to change the whitespace arbitrarily (e.g. comments).
1905	// Other tokens, like string literals, can be broken on arbitrary
1906	// positions.
1907
1908	// First, compute the columns from TailOffset to the next possible split
1909	// position.
1910	// For example:
1911	// ColumnLimit: \|
1912	// // Some text that breaks
1913	// ^ tail offset
1914	// ^-- split
1915	// ^-------- to split columns
1916	// ^--- next split
1917	// ^--------------- to next split columns
1918	unsigned ToSplitColumns = Token->getRangeLength(
1919	LineIndex, TailOffset, Split.first, ContentStartColumn);
1920	LLVM_DEBUG(llvm::dbgs() << " ToSplit: " << ToSplitColumns << "\n");
1921
1922	BreakableToken::Split NextSplit = Token->getSplit(
1923	LineIndex, TailOffset + Split.first + Split.second, ColumnLimit,
1924	ContentStartColumn + ToSplitColumns + 1, CommentPragmasRegex);
1925	// Compute the columns necessary to fit the next non-breakable sequence
1926	// into the current line.
1927	unsigned ToNextSplitColumns = 0;
1928	if (NextSplit.first == StringRef::npos) {
1929	ToNextSplitColumns = Token->getRemainingLength(LineIndex, TailOffset,
1930	ContentStartColumn);
1931	} else {
1932	ToNextSplitColumns = Token->getRangeLength(
1933	LineIndex, TailOffset,
1934	Split.first + Split.second + NextSplit.first, ContentStartColumn);
1935	}
1936	// Compress the whitespace between the break and the start of the next
1937	// unbreakable sequence.
1938	ToNextSplitColumns =
1939	Token->getLengthAfterCompression(ToNextSplitColumns, Split);
1940	LLVM_DEBUG(llvm::dbgs()
1941	<< " ContentStartColumn: " << ContentStartColumn << "\n");
1942	LLVM_DEBUG(llvm::dbgs()
1943	<< " ToNextSplit: " << ToNextSplitColumns << "\n");
1944	// If the whitespace compression makes us fit, continue on the current
1945	// line.
1946	bool ContinueOnLine =
1947	ContentStartColumn + ToNextSplitColumns <= ColumnLimit;
1948	unsigned ExcessCharactersPenalty = 0;
1949	if (!ContinueOnLine && !Strict) {
1950	// Similarly, if the excess characters' penalty is lower than the
1951	// penalty of introducing a new break, continue on the current line.
1952	ExcessCharactersPenalty =
1953	(ContentStartColumn + ToNextSplitColumns - ColumnLimit) *
1954	Style.PenaltyExcessCharacter;
1955	LLVM_DEBUG(llvm::dbgs()
1956	<< " Penalty excess: " << ExcessCharactersPenalty
1957	<< "\n break : " << NewBreakPenalty << "\n");
1958	if (ExcessCharactersPenalty < NewBreakPenalty) {
1959	Exceeded = true;
1960	ContinueOnLine = true;
1961	}
1962	}
1963	if (ContinueOnLine) {
1964	LLVM_DEBUG(llvm::dbgs() << " Continuing on line...\n");
1965	// The current line fits after compressing the whitespace - reflow
1966	// the next line into it if possible.
1967	TryReflow = true;
1968	if (!DryRun)
1969	Token->compressWhitespace(LineIndex, TailOffset, Split,
1970	Whitespaces);
1971	// When we continue on the same line, leave one space between content.
1972	ContentStartColumn += ToSplitColumns + 1;
1973	Penalty += ExcessCharactersPenalty;
1974	TailOffset += Split.first + Split.second;
1975	RemainingTokenColumns = Token->getRemainingLength(
1976	LineIndex, TailOffset, ContentStartColumn);
1977	continue;
1978	}
1979	}
1980	LLVM_DEBUG(llvm::dbgs() << " Breaking...\n");
1981	// Update the ContentIndent only if the current line was not reflown with
1982	// the previous line, since in that case the previous line should still
1983	// determine the ContentIndent. Also never intent the last line.
1984	if (!Reflow)
1985	ContentIndent = Token->getContentIndent(LineIndex);
1986	LLVM_DEBUG(llvm::dbgs()
1987	<< " ContentIndent: " << ContentIndent << "\n");
1988	ContentStartColumn = ContentIndent + Token->getContentStartColumn(
1989	LineIndex, /Break=/true);
1990
1991	unsigned NewRemainingTokenColumns = Token->getRemainingLength(
1992	LineIndex, TailOffset + Split.first + Split.second,
1993	ContentStartColumn);
1994	if (NewRemainingTokenColumns == 0) {
1995	// No content to indent.
1996	ContentIndent = 0;
1997	ContentStartColumn =
1998	Token->getContentStartColumn(LineIndex, /Break=/true);
1999	NewRemainingTokenColumns = Token->getRemainingLength(
2000	LineIndex, TailOffset + Split.first + Split.second,
2001	ContentStartColumn);
2002	}
2003
2004	// When breaking before a tab character, it may be moved by a few columns,
2005	// but will still be expanded to the next tab stop, so we don't save any
2006	// columns.
2007	if (NewRemainingTokenColumns == RemainingTokenColumns) {
2008	// FIXME: Do we need to adjust the penalty?
2009	break;
2010	}
2011	assert(NewRemainingTokenColumns < RemainingTokenColumns);
2012
2013	LLVM_DEBUG(llvm::dbgs() << " Breaking at: " << TailOffset + Split.first
2014	<< ", " << Split.second << "\n");
2015	if (!DryRun)
2016	Token->insertBreak(LineIndex, TailOffset, Split, ContentIndent,
2017	Whitespaces);
2018
2019	Penalty += NewBreakPenalty;
2020	TailOffset += Split.first + Split.second;
2021	RemainingTokenColumns = NewRemainingTokenColumns;
2022	BreakInserted = true;
2023	NewBreakBefore = true;
2024	}
2025	// In case there's another line, prepare the state for the start of the next
2026	// line.
2027	if (LineIndex + 1 != EndIndex) {
2028	unsigned NextLineIndex = LineIndex + 1;
2029	if (NewBreakBefore)
2030	// After breaking a line, try to reflow the next line into the current
2031	// one once RemainingTokenColumns fits.
2032	TryReflow = true;
2033	if (TryReflow) {
2034	// We decided that we want to try reflowing the next line into the
2035	// current one.
2036	// We will now adjust the state as if the reflow is successful (in
2037	// preparation for the next line), and see whether that works. If we
2038	// decide that we cannot reflow, we will later reset the state to the
2039	// start of the next line.
2040	Reflow = false;
2041	// As we did not continue breaking the line, RemainingTokenColumns is
2042	// known to fit after ContentStartColumn. Adapt ContentStartColumn to
2043	// the position at which we want to format the next line if we do
2044	// actually reflow.
2045	// When we reflow, we need to add a space between the end of the current
2046	// line and the next line's start column.
2047	ContentStartColumn += RemainingTokenColumns + 1;
2048	// Get the split that we need to reflow next logical line into the end
2049	// of the current one; the split will include any leading whitespace of
2050	// the next logical line.
2051	BreakableToken::Split SplitBeforeNext =
2052	Token->getReflowSplit(NextLineIndex, CommentPragmasRegex);
2053	LLVM_DEBUG(llvm::dbgs()
2054	<< " Size of reflown text: " << ContentStartColumn
2055	<< "\n Potential reflow split: ");
2056	if (SplitBeforeNext.first != StringRef::npos) {
2057	LLVM_DEBUG(llvm::dbgs() << SplitBeforeNext.first << ", "
2058	<< SplitBeforeNext.second << "\n");
2059	TailOffset = SplitBeforeNext.first + SplitBeforeNext.second;
2060	// If the rest of the next line fits into the current line below the
2061	// column limit, we can safely reflow.
2062	RemainingTokenColumns = Token->getRemainingLength(
2063	NextLineIndex, TailOffset, ContentStartColumn);
2064	Reflow = true;
2065	if (ContentStartColumn + RemainingTokenColumns > ColumnLimit) {
2066	LLVM_DEBUG(llvm::dbgs()
2067	<< " Over limit after reflow, need: "
2068	<< (ContentStartColumn + RemainingTokenColumns)
2069	<< ", space: " << ColumnLimit
2070	<< ", reflown prefix: " << ContentStartColumn
2071	<< ", offset in line: " << TailOffset << "\n");
2072	// If the whole next line does not fit, try to find a point in
2073	// the next line at which we can break so that attaching the part
2074	// of the next line to that break point onto the current line is
2075	// below the column limit.
2076	BreakableToken::Split Split =
2077	Token->getSplit(NextLineIndex, TailOffset, ColumnLimit,
2078	ContentStartColumn, CommentPragmasRegex);
2079	if (Split.first == StringRef::npos) {
2080	LLVM_DEBUG(llvm::dbgs() << " Did not find later break\n");
2081	Reflow = false;
2082	} else {
2083	// Check whether the first split point gets us below the column
2084	// limit. Note that we will execute this split below as part of
2085	// the normal token breaking and reflow logic within the line.
2086	unsigned ToSplitColumns = Token->getRangeLength(
2087	NextLineIndex, TailOffset, Split.first, ContentStartColumn);
2088	if (ContentStartColumn + ToSplitColumns > ColumnLimit) {
2089	LLVM_DEBUG(llvm::dbgs() << " Next split protrudes, need: "
2090	<< (ContentStartColumn + ToSplitColumns)
2091	<< ", space: " << ColumnLimit);
2092	unsigned ExcessCharactersPenalty =
2093	(ContentStartColumn + ToSplitColumns - ColumnLimit) *
2094	Style.PenaltyExcessCharacter;
2095	if (NewBreakPenalty < ExcessCharactersPenalty) {
2096	Reflow = false;
2097	}
2098	}
2099	}
2100	}
2101	} else {
2102	LLVM_DEBUG(llvm::dbgs() << "not found.\n");
2103	}
2104	}
2105	if (!Reflow) {
2106	// If we didn't reflow into the next line, the only space to consider is
2107	// the next logical line. Reset our state to match the start of the next
2108	// line.
2109	TailOffset = 0;
2110	ContentStartColumn =
2111	Token->getContentStartColumn(NextLineIndex, /Break=/false);
2112	RemainingTokenColumns = Token->getRemainingLength(
2113	NextLineIndex, TailOffset, ContentStartColumn);
2114	// Adapt the start of the token, for example indent.
2115	if (!DryRun)
2116	Token->adaptStartOfLine(NextLineIndex, Whitespaces);
2117	} else {
2118	// If we found a reflow split and have added a new break before the next
2119	// line, we are going to remove the line break at the start of the next
2120	// logical line. For example, here we'll add a new line break after
2121	// 'text', and subsequently delete the line break between 'that' and
2122	// 'reflows'.
2123	// // some text that
2124	// // reflows
2125	// ->
2126	// // some text
2127	// // that reflows
2128	// When adding the line break, we also added the penalty for it, so we
2129	// need to subtract that penalty again when we remove the line break due
2130	// to reflowing.
2131	if (NewBreakBefore) {
2132	= NewBreakPenalty", "/home/seafit/code_projects/clang_source/clang/lib/Format/ContinuationIndenter.cpp", 2132, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(Penalty >= NewBreakPenalty);
2133	Penalty -= NewBreakPenalty;
2134	}
2135	if (!DryRun)
2136	Token->reflow(NextLineIndex, Whitespaces);
2137	}
2138	}
2139	}
2140
2141	BreakableToken::Split SplitAfterLastLine =
2142	Token->getSplitAfterLastLine(TailOffset);
2143	if (SplitAfterLastLine.first != StringRef::npos) {
2144	LLVM_DEBUG(llvm::dbgs() << "Replacing whitespace after last line.\n");
2145
2146	// We add the last line's penalty here, since that line is going to be split
2147	// now.
2148	Penalty += Style.PenaltyExcessCharacter *
2149	(ContentStartColumn + RemainingTokenColumns - ColumnLimit);
2150
2151	if (!DryRun)
2152	Token->replaceWhitespaceAfterLastLine(TailOffset, SplitAfterLastLine,
2153	Whitespaces);
2154	ContentStartColumn =
2155	Token->getContentStartColumn(Token->getLineCount() - 1, /Break=/true);
2156	RemainingTokenColumns = Token->getRemainingLength(
2157	Token->getLineCount() - 1,
2158	TailOffset + SplitAfterLastLine.first + SplitAfterLastLine.second,
2159	ContentStartColumn);
2160	}
2161
2162	State.Column = ContentStartColumn + RemainingTokenColumns -
2163	Current.UnbreakableTailLength;
2164
2165	if (BreakInserted) {
2166	// If we break the token inside a parameter list, we need to break before
2167	// the next parameter on all levels, so that the next parameter is clearly
2168	// visible. Line comments already introduce a break.
2169	if (Current.isNot(TT_LineComment)) {
2170	for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
2171	State.Stack[i].BreakBeforeParameter = true;
2172	}
2173
2174	if (Current.is(TT_BlockComment))
2175	State.NoContinuation = true;
2176
2177	State.Stack.back().LastSpace = StartColumn;
2178	}
2179
2180	Token->updateNextToken(State);
2181
2182	return {Penalty, Exceeded};
2183	}
2184
2185	unsigned ContinuationIndenter::getColumnLimit(const LineState &State) const {
2186	// In preprocessor directives reserve two chars for trailing " \"
2187	return Style.ColumnLimit - (State.Line->InPPDirective ? 2 : 0);
2188	}
2189
2190	bool ContinuationIndenter::nextIsMultilineString(const LineState &State) {
2191	const FormatToken &Current = *State.NextToken;
2192	if (!Current.isStringLiteral() \|\| Current.is(TT_ImplicitStringLiteral))
2193	return false;
2194	// We never consider raw string literals "multiline" for the purpose of
2195	// AlwaysBreakBeforeMultilineStrings implementation as they are special-cased
2196	// (see TokenAnnotator::mustBreakBefore().
2197	if (Current.TokenText.startswith("R\""))
2198	return false;
2199	if (Current.IsMultiline)
2200	return true;
2201	if (Current.getNextNonComment() &&
2202	Current.getNextNonComment()->isStringLiteral())
2203	return true; // Implicit concatenation.
2204	if (Style.ColumnLimit != 0 && Style.BreakStringLiterals &&
2205	State.Column + Current.ColumnWidth + Current.UnbreakableTailLength >
2206	Style.ColumnLimit)
2207	return true; // String will be split.
2208	return false;
2209	}
2210
2211	} // namespace format
2212	} // namespace clang
2213

Clang Project