Bug Summary

File:tools/clang/lib/Format/UnwrappedLineFormatter.cpp
Warning:line 1146, column 11
Access to field 'NewlinesBefore' results in a dereference of a null pointer (loaded from field 'First')

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name UnwrappedLineFormatter.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/tools/clang/lib/Format -I /build/llvm-toolchain-snapshot-10~svn374877/tools/clang/lib/Format -I /build/llvm-toolchain-snapshot-10~svn374877/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/include -I /build/llvm-toolchain-snapshot-10~svn374877/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/tools/clang/lib/Format -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~svn374877=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-10-15-233810-7101-1 -x c++ /build/llvm-toolchain-snapshot-10~svn374877/tools/clang/lib/Format/UnwrappedLineFormatter.cpp
1//===--- UnwrappedLineFormatter.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#include "UnwrappedLineFormatter.h"
10#include "NamespaceEndCommentsFixer.h"
11#include "WhitespaceManager.h"
12#include "llvm/Support/Debug.h"
13#include <queue>
14
15#define DEBUG_TYPE"format-formatter" "format-formatter"
16
17namespace clang {
18namespace format {
19
20namespace {
21
22bool startsExternCBlock(const AnnotatedLine &Line) {
23 const FormatToken *Next = Line.First->getNextNonComment();
24 const FormatToken *NextNext = Next ? Next->getNextNonComment() : nullptr;
25 return Line.startsWith(tok::kw_extern) && Next && Next->isStringLiteral() &&
26 NextNext && NextNext->is(tok::l_brace);
27}
28
29/// Tracks the indent level of \c AnnotatedLines across levels.
30///
31/// \c nextLine must be called for each \c AnnotatedLine, after which \c
32/// getIndent() will return the indent for the last line \c nextLine was called
33/// with.
34/// If the line is not formatted (and thus the indent does not change), calling
35/// \c adjustToUnmodifiedLine after the call to \c nextLine will cause
36/// subsequent lines on the same level to be indented at the same level as the
37/// given line.
38class LevelIndentTracker {
39public:
40 LevelIndentTracker(const FormatStyle &Style,
41 const AdditionalKeywords &Keywords, unsigned StartLevel,
42 int AdditionalIndent)
43 : Style(Style), Keywords(Keywords), AdditionalIndent(AdditionalIndent) {
44 for (unsigned i = 0; i != StartLevel; ++i)
45 IndentForLevel.push_back(Style.IndentWidth * i + AdditionalIndent);
46 }
47
48 /// Returns the indent for the current line.
49 unsigned getIndent() const { return Indent; }
50
51 /// Update the indent state given that \p Line is going to be formatted
52 /// next.
53 void nextLine(const AnnotatedLine &Line) {
54 Offset = getIndentOffset(*Line.First);
55 // Update the indent level cache size so that we can rely on it
56 // having the right size in adjustToUnmodifiedline.
57 while (IndentForLevel.size() <= Line.Level)
58 IndentForLevel.push_back(-1);
59 if (Line.InPPDirective) {
60 Indent = Line.Level * Style.IndentWidth + AdditionalIndent;
61 } else {
62 IndentForLevel.resize(Line.Level + 1);
63 Indent = getIndent(IndentForLevel, Line.Level);
64 }
65 if (static_cast<int>(Indent) + Offset >= 0)
66 Indent += Offset;
67 }
68
69 /// Update the indent state given that \p Line indent should be
70 /// skipped.
71 void skipLine(const AnnotatedLine &Line) {
72 while (IndentForLevel.size() <= Line.Level)
73 IndentForLevel.push_back(Indent);
74 }
75
76 /// Update the level indent to adapt to the given \p Line.
77 ///
78 /// When a line is not formatted, we move the subsequent lines on the same
79 /// level to the same indent.
80 /// Note that \c nextLine must have been called before this method.
81 void adjustToUnmodifiedLine(const AnnotatedLine &Line) {
82 unsigned LevelIndent = Line.First->OriginalColumn;
83 if (static_cast<int>(LevelIndent) - Offset >= 0)
84 LevelIndent -= Offset;
85 if ((!Line.First->is(tok::comment) || IndentForLevel[Line.Level] == -1) &&
86 !Line.InPPDirective)
87 IndentForLevel[Line.Level] = LevelIndent;
88 }
89
90private:
91 /// Get the offset of the line relatively to the level.
92 ///
93 /// For example, 'public:' labels in classes are offset by 1 or 2
94 /// characters to the left from their level.
95 int getIndentOffset(const FormatToken &RootToken) {
96 if (Style.Language == FormatStyle::LK_Java ||
97 Style.Language == FormatStyle::LK_JavaScript || Style.isCSharp())
98 return 0;
99 if (RootToken.isAccessSpecifier(false) ||
100 RootToken.isObjCAccessSpecifier() ||
101 (RootToken.isOneOf(Keywords.kw_signals, Keywords.kw_qsignals) &&
102 RootToken.Next && RootToken.Next->is(tok::colon)))
103 return Style.AccessModifierOffset;
104 return 0;
105 }
106
107 /// Get the indent of \p Level from \p IndentForLevel.
108 ///
109 /// \p IndentForLevel must contain the indent for the level \c l
110 /// at \p IndentForLevel[l], or a value < 0 if the indent for
111 /// that level is unknown.
112 unsigned getIndent(ArrayRef<int> IndentForLevel, unsigned Level) {
113 if (IndentForLevel[Level] != -1)
114 return IndentForLevel[Level];
115 if (Level == 0)
116 return 0;
117 return getIndent(IndentForLevel, Level - 1) + Style.IndentWidth;
118 }
119
120 const FormatStyle &Style;
121 const AdditionalKeywords &Keywords;
122 const unsigned AdditionalIndent;
123
124 /// The indent in characters for each level.
125 std::vector<int> IndentForLevel;
126
127 /// Offset of the current line relative to the indent level.
128 ///
129 /// For example, the 'public' keywords is often indented with a negative
130 /// offset.
131 int Offset = 0;
132
133 /// The current line's indent.
134 unsigned Indent = 0;
135};
136
137const FormatToken *getMatchingNamespaceToken(
138 const AnnotatedLine *Line,
139 const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
140 if (!Line->startsWith(tok::r_brace))
141 return nullptr;
142 size_t StartLineIndex = Line->MatchingOpeningBlockLineIndex;
143 if (StartLineIndex == UnwrappedLine::kInvalidIndex)
144 return nullptr;
145 assert(StartLineIndex < AnnotatedLines.size())((StartLineIndex < AnnotatedLines.size()) ? static_cast<
void> (0) : __assert_fail ("StartLineIndex < AnnotatedLines.size()"
, "/build/llvm-toolchain-snapshot-10~svn374877/tools/clang/lib/Format/UnwrappedLineFormatter.cpp"
, 145, __PRETTY_FUNCTION__))
;
146 return AnnotatedLines[StartLineIndex]->First->getNamespaceToken();
147}
148
149StringRef getNamespaceTokenText(const AnnotatedLine *Line) {
150 const FormatToken *NamespaceToken = Line->First->getNamespaceToken();
151 return NamespaceToken ? NamespaceToken->TokenText : StringRef();
152}
153
154StringRef getMatchingNamespaceTokenText(
155 const AnnotatedLine *Line,
156 const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
157 const FormatToken *NamespaceToken =
158 getMatchingNamespaceToken(Line, AnnotatedLines);
159 return NamespaceToken ? NamespaceToken->TokenText : StringRef();
160}
161
162class LineJoiner {
163public:
164 LineJoiner(const FormatStyle &Style, const AdditionalKeywords &Keywords,
165 const SmallVectorImpl<AnnotatedLine *> &Lines)
166 : Style(Style), Keywords(Keywords), End(Lines.end()), Next(Lines.begin()),
167 AnnotatedLines(Lines) {}
168
169 /// Returns the next line, merging multiple lines into one if possible.
170 const AnnotatedLine *getNextMergedLine(bool DryRun,
171 LevelIndentTracker &IndentTracker) {
172 if (Next == End)
22
Assuming field 'Next' is not equal to field 'End'
23
Taking false branch
40
Assuming field 'Next' is not equal to field 'End'
41
Taking false branch
173 return nullptr;
174 const AnnotatedLine *Current = *Next;
175 IndentTracker.nextLine(*Current);
176 unsigned MergedLines = tryFitMultipleLinesInOne(IndentTracker, Next, End);
177 if (MergedLines > 0 && Style.ColumnLimit == 0)
24
Assuming 'MergedLines' is <= 0
42
Assuming 'MergedLines' is <= 0
178 // Disallow line merging if there is a break at the start of one of the
179 // input lines.
180 for (unsigned i = 0; i < MergedLines; ++i)
181 if (Next[i + 1]->First->NewlinesBefore > 0)
182 MergedLines = 0;
183 if (!DryRun
24.1
'DryRun' is false
42.1
'DryRun' is false
)
25
Taking true branch
43
Taking true branch
184 for (unsigned i = 0; i < MergedLines; ++i)
26
Loop condition is false. Execution continues on line 186
44
Loop condition is false. Execution continues on line 186
185 join(*Next[0], *Next[i + 1]);
186 Next = Next + MergedLines + 1;
187 return Current;
27
Returning pointer (loaded from 'Current'), which participates in a condition later
45
Returning pointer (loaded from 'Current'), which participates in a condition later
188 }
189
190private:
191 /// Calculates how many lines can be merged into 1 starting at \p I.
192 unsigned
193 tryFitMultipleLinesInOne(LevelIndentTracker &IndentTracker,
194 SmallVectorImpl<AnnotatedLine *>::const_iterator I,
195 SmallVectorImpl<AnnotatedLine *>::const_iterator E) {
196 const unsigned Indent = IndentTracker.getIndent();
197
198 // Can't join the last line with anything.
199 if (I + 1 == E)
200 return 0;
201 // We can never merge stuff if there are trailing line comments.
202 const AnnotatedLine *TheLine = *I;
203 if (TheLine->Last->is(TT_LineComment))
204 return 0;
205 if (I[1]->Type == LT_Invalid || I[1]->First->MustBreakBefore)
206 return 0;
207 if (TheLine->InPPDirective &&
208 (!I[1]->InPPDirective || I[1]->First->HasUnescapedNewline))
209 return 0;
210
211 if (Style.ColumnLimit > 0 && Indent > Style.ColumnLimit)
212 return 0;
213
214 unsigned Limit =
215 Style.ColumnLimit == 0 ? UINT_MAX(2147483647 *2U +1U) : Style.ColumnLimit - Indent;
216 // If we already exceed the column limit, we set 'Limit' to 0. The different
217 // tryMerge..() functions can then decide whether to still do merging.
218 Limit = TheLine->Last->TotalLength > Limit
219 ? 0
220 : Limit - TheLine->Last->TotalLength;
221
222 if (TheLine->Last->is(TT_FunctionLBrace) &&
223 TheLine->First == TheLine->Last &&
224 !Style.BraceWrapping.SplitEmptyFunction &&
225 I[1]->First->is(tok::r_brace))
226 return tryMergeSimpleBlock(I, E, Limit);
227
228 // Handle empty record blocks where the brace has already been wrapped
229 if (TheLine->Last->is(tok::l_brace) && TheLine->First == TheLine->Last &&
230 I != AnnotatedLines.begin()) {
231 bool EmptyBlock = I[1]->First->is(tok::r_brace);
232
233 const FormatToken *Tok = I[-1]->First;
234 if (Tok && Tok->is(tok::comment))
235 Tok = Tok->getNextNonComment();
236
237 if (Tok && Tok->getNamespaceToken())
238 return !Style.BraceWrapping.SplitEmptyNamespace && EmptyBlock
239 ? tryMergeSimpleBlock(I, E, Limit)
240 : 0;
241
242 if (Tok && Tok->is(tok::kw_typedef))
243 Tok = Tok->getNextNonComment();
244 if (Tok && Tok->isOneOf(tok::kw_class, tok::kw_struct, tok::kw_union,
245 tok::kw_extern, Keywords.kw_interface))
246 return !Style.BraceWrapping.SplitEmptyRecord && EmptyBlock
247 ? tryMergeSimpleBlock(I, E, Limit)
248 : 0;
249 }
250
251 // FIXME: TheLine->Level != 0 might or might not be the right check to do.
252 // If necessary, change to something smarter.
253 bool MergeShortFunctions =
254 Style.AllowShortFunctionsOnASingleLine == FormatStyle::SFS_All ||
255 (Style.AllowShortFunctionsOnASingleLine >= FormatStyle::SFS_Empty &&
256 I[1]->First->is(tok::r_brace)) ||
257 (Style.AllowShortFunctionsOnASingleLine & FormatStyle::SFS_InlineOnly &&
258 TheLine->Level != 0);
259
260 if (Style.CompactNamespaces) {
261 if (auto nsToken = TheLine->First->getNamespaceToken()) {
262 int i = 0;
263 unsigned closingLine = TheLine->MatchingClosingBlockLineIndex - 1;
264 for (; I + 1 + i != E &&
265 nsToken->TokenText == getNamespaceTokenText(I[i + 1]) &&
266 closingLine == I[i + 1]->MatchingClosingBlockLineIndex &&
267 I[i + 1]->Last->TotalLength < Limit;
268 i++, closingLine--) {
269 // No extra indent for compacted namespaces
270 IndentTracker.skipLine(*I[i + 1]);
271
272 Limit -= I[i + 1]->Last->TotalLength;
273 }
274 return i;
275 }
276
277 if (auto nsToken = getMatchingNamespaceToken(TheLine, AnnotatedLines)) {
278 int i = 0;
279 unsigned openingLine = TheLine->MatchingOpeningBlockLineIndex - 1;
280 for (; I + 1 + i != E &&
281 nsToken->TokenText ==
282 getMatchingNamespaceTokenText(I[i + 1], AnnotatedLines) &&
283 openingLine == I[i + 1]->MatchingOpeningBlockLineIndex;
284 i++, openingLine--) {
285 // No space between consecutive braces
286 I[i + 1]->First->SpacesRequiredBefore = !I[i]->Last->is(tok::r_brace);
287
288 // Indent like the outer-most namespace
289 IndentTracker.nextLine(*I[i + 1]);
290 }
291 return i;
292 }
293 }
294
295 // Try to merge a function block with left brace unwrapped
296 if (TheLine->Last->is(TT_FunctionLBrace) &&
297 TheLine->First != TheLine->Last) {
298 return MergeShortFunctions ? tryMergeSimpleBlock(I, E, Limit) : 0;
299 }
300 // Try to merge a control statement block with left brace unwrapped
301 if (TheLine->Last->is(tok::l_brace) && TheLine->First != TheLine->Last &&
302 TheLine->First->isOneOf(tok::kw_if, tok::kw_while, tok::kw_for)) {
303 return Style.AllowShortBlocksOnASingleLine != FormatStyle::SBS_Never
304 ? tryMergeSimpleBlock(I, E, Limit)
305 : 0;
306 }
307 // Try to merge a control statement block with left brace wrapped
308 if (I[1]->First->is(tok::l_brace) &&
309 (TheLine->First->isOneOf(tok::kw_if, tok::kw_while, tok::kw_for,
310 tok::kw_switch, tok::kw_try, tok::kw_do) ||
311 (TheLine->First->is(tok::r_brace) && TheLine->First->Next &&
312 TheLine->First->Next->isOneOf(tok::kw_else, tok::kw_catch))) &&
313 Style.BraceWrapping.AfterControlStatement ==
314 FormatStyle::BWACS_MultiLine) {
315 // If possible, merge the next line's wrapped left brace with the current
316 // line. Otherwise, leave it on the next line, as this is a multi-line
317 // control statement.
318 return (Style.ColumnLimit == 0 ||
319 TheLine->Last->TotalLength <= Style.ColumnLimit)
320 ? 1
321 : 0;
322 } else if (I[1]->First->is(tok::l_brace) &&
323 TheLine->First->isOneOf(tok::kw_if, tok::kw_while,
324 tok::kw_for)) {
325 return (Style.BraceWrapping.AfterControlStatement ==
326 FormatStyle::BWACS_Always)
327 ? tryMergeSimpleBlock(I, E, Limit)
328 : 0;
329 }
330 // Try to merge either empty or one-line block if is precedeed by control
331 // statement token
332 if (TheLine->First->is(tok::l_brace) && TheLine->First == TheLine->Last &&
333 I != AnnotatedLines.begin() &&
334 I[-1]->First->isOneOf(tok::kw_if, tok::kw_while, tok::kw_for)) {
335 unsigned MergedLines = 0;
336 if (Style.AllowShortBlocksOnASingleLine != FormatStyle::SBS_Never) {
337 MergedLines = tryMergeSimpleBlock(I - 1, E, Limit);
338 // If we managed to merge the block, discard the first merged line
339 // since we are merging starting from I.
340 if (MergedLines > 0)
341 --MergedLines;
342 }
343 return MergedLines;
344 }
345 // Don't merge block with left brace wrapped after ObjC special blocks
346 if (TheLine->First->is(tok::l_brace) && I != AnnotatedLines.begin() &&
347 I[-1]->First->is(tok::at) && I[-1]->First->Next) {
348 tok::ObjCKeywordKind kwId = I[-1]->First->Next->Tok.getObjCKeywordID();
349 if (kwId == clang::tok::objc_autoreleasepool ||
350 kwId == clang::tok::objc_synchronized)
351 return 0;
352 }
353 // Don't merge block with left brace wrapped after case labels
354 if (TheLine->First->is(tok::l_brace) && I != AnnotatedLines.begin() &&
355 I[-1]->First->isOneOf(tok::kw_case, tok::kw_default))
356 return 0;
357 // Try to merge a block with left brace wrapped that wasn't yet covered
358 if (TheLine->Last->is(tok::l_brace)) {
359 return !Style.BraceWrapping.AfterFunction ||
360 (I[1]->First->is(tok::r_brace) &&
361 !Style.BraceWrapping.SplitEmptyRecord)
362 ? tryMergeSimpleBlock(I, E, Limit)
363 : 0;
364 }
365 // Try to merge a function block with left brace wrapped
366 if (I[1]->First->is(TT_FunctionLBrace) &&
367 Style.BraceWrapping.AfterFunction) {
368 if (I[1]->Last->is(TT_LineComment))
369 return 0;
370
371 // Check for Limit <= 2 to account for the " {".
372 if (Limit <= 2 || (Style.ColumnLimit == 0 && containsMustBreak(TheLine)))
373 return 0;
374 Limit -= 2;
375
376 unsigned MergedLines = 0;
377 if (MergeShortFunctions ||
378 (Style.AllowShortFunctionsOnASingleLine >= FormatStyle::SFS_Empty &&
379 I[1]->First == I[1]->Last && I + 2 != E &&
380 I[2]->First->is(tok::r_brace))) {
381 MergedLines = tryMergeSimpleBlock(I + 1, E, Limit);
382 // If we managed to merge the block, count the function header, which is
383 // on a separate line.
384 if (MergedLines > 0)
385 ++MergedLines;
386 }
387 return MergedLines;
388 }
389 if (TheLine->First->is(tok::kw_if)) {
390 return Style.AllowShortIfStatementsOnASingleLine
391 ? tryMergeSimpleControlStatement(I, E, Limit)
392 : 0;
393 }
394 if (TheLine->First->isOneOf(tok::kw_for, tok::kw_while)) {
395 return Style.AllowShortLoopsOnASingleLine
396 ? tryMergeSimpleControlStatement(I, E, Limit)
397 : 0;
398 }
399 if (TheLine->First->isOneOf(tok::kw_case, tok::kw_default)) {
400 return Style.AllowShortCaseLabelsOnASingleLine
401 ? tryMergeShortCaseLabels(I, E, Limit)
402 : 0;
403 }
404 if (TheLine->InPPDirective &&
405 (TheLine->First->HasUnescapedNewline || TheLine->First->IsFirst)) {
406 return tryMergeSimplePPDirective(I, E, Limit);
407 }
408 return 0;
409 }
410
411 unsigned
412 tryMergeSimplePPDirective(SmallVectorImpl<AnnotatedLine *>::const_iterator I,
413 SmallVectorImpl<AnnotatedLine *>::const_iterator E,
414 unsigned Limit) {
415 if (Limit == 0)
416 return 0;
417 if (I + 2 != E && I[2]->InPPDirective && !I[2]->First->HasUnescapedNewline)
418 return 0;
419 if (1 + I[1]->Last->TotalLength > Limit)
420 return 0;
421 return 1;
422 }
423
424 unsigned tryMergeSimpleControlStatement(
425 SmallVectorImpl<AnnotatedLine *>::const_iterator I,
426 SmallVectorImpl<AnnotatedLine *>::const_iterator E, unsigned Limit) {
427 if (Limit == 0)
428 return 0;
429 if (Style.BraceWrapping.AfterControlStatement ==
430 FormatStyle::BWACS_Always &&
431 I[1]->First->is(tok::l_brace) &&
432 Style.AllowShortBlocksOnASingleLine == FormatStyle::SBS_Never)
433 return 0;
434 if (I[1]->InPPDirective != (*I)->InPPDirective ||
435 (I[1]->InPPDirective && I[1]->First->HasUnescapedNewline))
436 return 0;
437 Limit = limitConsideringMacros(I + 1, E, Limit);
438 AnnotatedLine &Line = **I;
439 if (Line.Last->isNot(tok::r_paren))
440 return 0;
441 if (1 + I[1]->Last->TotalLength > Limit)
442 return 0;
443 if (I[1]->First->isOneOf(tok::semi, tok::kw_if, tok::kw_for, tok::kw_while,
444 TT_LineComment))
445 return 0;
446 // Only inline simple if's (no nested if or else), unless specified
447 if (Style.AllowShortIfStatementsOnASingleLine != FormatStyle::SIS_Always) {
448 if (I + 2 != E && Line.startsWith(tok::kw_if) &&
449 I[2]->First->is(tok::kw_else))
450 return 0;
451 }
452 return 1;
453 }
454
455 unsigned
456 tryMergeShortCaseLabels(SmallVectorImpl<AnnotatedLine *>::const_iterator I,
457 SmallVectorImpl<AnnotatedLine *>::const_iterator E,
458 unsigned Limit) {
459 if (Limit == 0 || I + 1 == E ||
460 I[1]->First->isOneOf(tok::kw_case, tok::kw_default))
461 return 0;
462 if (I[0]->Last->is(tok::l_brace) || I[1]->First->is(tok::l_brace))
463 return 0;
464 unsigned NumStmts = 0;
465 unsigned Length = 0;
466 bool EndsWithComment = false;
467 bool InPPDirective = I[0]->InPPDirective;
468 const unsigned Level = I[0]->Level;
469 for (; NumStmts < 3; ++NumStmts) {
470 if (I + 1 + NumStmts == E)
471 break;
472 const AnnotatedLine *Line = I[1 + NumStmts];
473 if (Line->InPPDirective != InPPDirective)
474 break;
475 if (Line->First->isOneOf(tok::kw_case, tok::kw_default, tok::r_brace))
476 break;
477 if (Line->First->isOneOf(tok::kw_if, tok::kw_for, tok::kw_switch,
478 tok::kw_while) ||
479 EndsWithComment)
480 return 0;
481 if (Line->First->is(tok::comment)) {
482 if (Level != Line->Level)
483 return 0;
484 SmallVectorImpl<AnnotatedLine *>::const_iterator J = I + 2 + NumStmts;
485 for (; J != E; ++J) {
486 Line = *J;
487 if (Line->InPPDirective != InPPDirective)
488 break;
489 if (Line->First->isOneOf(tok::kw_case, tok::kw_default, tok::r_brace))
490 break;
491 if (Line->First->isNot(tok::comment) || Level != Line->Level)
492 return 0;
493 }
494 break;
495 }
496 if (Line->Last->is(tok::comment))
497 EndsWithComment = true;
498 Length += I[1 + NumStmts]->Last->TotalLength + 1; // 1 for the space.
499 }
500 if (NumStmts == 0 || NumStmts == 3 || Length > Limit)
501 return 0;
502 return NumStmts;
503 }
504
505 unsigned
506 tryMergeSimpleBlock(SmallVectorImpl<AnnotatedLine *>::const_iterator I,
507 SmallVectorImpl<AnnotatedLine *>::const_iterator E,
508 unsigned Limit) {
509 AnnotatedLine &Line = **I;
510
511 // Don't merge ObjC @ keywords and methods.
512 // FIXME: If an option to allow short exception handling clauses on a single
513 // line is added, change this to not return for @try and friends.
514 if (Style.Language != FormatStyle::LK_Java &&
515 Line.First->isOneOf(tok::at, tok::minus, tok::plus))
516 return 0;
517
518 // Check that the current line allows merging. This depends on whether we
519 // are in a control flow statements as well as several style flags.
520 if (Line.First->isOneOf(tok::kw_else, tok::kw_case) ||
521 (Line.First->Next && Line.First->Next->is(tok::kw_else)))
522 return 0;
523 // default: in switch statement
524 if (Line.First->is(tok::kw_default)) {
525 const FormatToken *Tok = Line.First->getNextNonComment();
526 if (Tok && Tok->is(tok::colon))
527 return 0;
528 }
529 if (Line.First->isOneOf(tok::kw_if, tok::kw_while, tok::kw_do, tok::kw_try,
530 tok::kw___try, tok::kw_catch, tok::kw___finally,
531 tok::kw_for, tok::r_brace, Keywords.kw___except)) {
532 if (Style.AllowShortBlocksOnASingleLine == FormatStyle::SBS_Never)
533 return 0;
534 // Don't merge when we can't except the case when
535 // the control statement block is empty
536 if (!Style.AllowShortIfStatementsOnASingleLine &&
537 Line.startsWith(tok::kw_if) &&
538 !Style.BraceWrapping.AfterControlStatement &&
539 !I[1]->First->is(tok::r_brace))
540 return 0;
541 if (!Style.AllowShortIfStatementsOnASingleLine &&
542 Line.startsWith(tok::kw_if) &&
543 Style.BraceWrapping.AfterControlStatement ==
544 FormatStyle::BWACS_Always &&
545 I + 2 != E && !I[2]->First->is(tok::r_brace))
546 return 0;
547 if (!Style.AllowShortLoopsOnASingleLine &&
548 Line.First->isOneOf(tok::kw_while, tok::kw_do, tok::kw_for) &&
549 !Style.BraceWrapping.AfterControlStatement &&
550 !I[1]->First->is(tok::r_brace))
551 return 0;
552 if (!Style.AllowShortLoopsOnASingleLine &&
553 Line.First->isOneOf(tok::kw_while, tok::kw_do, tok::kw_for) &&
554 Style.BraceWrapping.AfterControlStatement ==
555 FormatStyle::BWACS_Always &&
556 I + 2 != E && !I[2]->First->is(tok::r_brace))
557 return 0;
558 // FIXME: Consider an option to allow short exception handling clauses on
559 // a single line.
560 // FIXME: This isn't covered by tests.
561 // FIXME: For catch, __except, __finally the first token on the line
562 // is '}', so this isn't correct here.
563 if (Line.First->isOneOf(tok::kw_try, tok::kw___try, tok::kw_catch,
564 Keywords.kw___except, tok::kw___finally))
565 return 0;
566 }
567
568 if (Line.Last->is(tok::l_brace)) {
569 FormatToken *Tok = I[1]->First;
570 if (Tok->is(tok::r_brace) && !Tok->MustBreakBefore &&
571 (Tok->getNextNonComment() == nullptr ||
572 Tok->getNextNonComment()->is(tok::semi))) {
573 // We merge empty blocks even if the line exceeds the column limit.
574 Tok->SpacesRequiredBefore = Style.SpaceInEmptyBlock ? 1 : 0;
575 Tok->CanBreakBefore = true;
576 return 1;
577 } else if (Limit != 0 && !Line.startsWithNamespace() &&
578 !startsExternCBlock(Line)) {
579 // We don't merge short records.
580 FormatToken *RecordTok = Line.First;
581 // Skip record modifiers.
582 while (RecordTok->Next &&
583 RecordTok->isOneOf(tok::kw_typedef, tok::kw_export,
584 Keywords.kw_declare, Keywords.kw_abstract,
585 tok::kw_default))
586 RecordTok = RecordTok->Next;
587 if (RecordTok &&
588 RecordTok->isOneOf(tok::kw_class, tok::kw_union, tok::kw_struct,
589 Keywords.kw_interface))
590 return 0;
591
592 // Check that we still have three lines and they fit into the limit.
593 if (I + 2 == E || I[2]->Type == LT_Invalid)
594 return 0;
595 Limit = limitConsideringMacros(I + 2, E, Limit);
596
597 if (!nextTwoLinesFitInto(I, Limit))
598 return 0;
599
600 // Second, check that the next line does not contain any braces - if it
601 // does, readability declines when putting it into a single line.
602 if (I[1]->Last->is(TT_LineComment))
603 return 0;
604 do {
605 if (Tok->is(tok::l_brace) && Tok->BlockKind != BK_BracedInit)
606 return 0;
607 Tok = Tok->Next;
608 } while (Tok);
609
610 // Last, check that the third line starts with a closing brace.
611 Tok = I[2]->First;
612 if (Tok->isNot(tok::r_brace))
613 return 0;
614
615 // Don't merge "if (a) { .. } else {".
616 if (Tok->Next && Tok->Next->is(tok::kw_else))
617 return 0;
618
619 // Don't merge a trailing multi-line control statement block like:
620 // } else if (foo &&
621 // bar)
622 // { <-- current Line
623 // baz();
624 // }
625 if (Line.First == Line.Last &&
626 Style.BraceWrapping.AfterControlStatement ==
627 FormatStyle::BWACS_MultiLine)
628 return 0;
629
630 return 2;
631 }
632 } else if (I[1]->First->is(tok::l_brace)) {
633 if (I[1]->Last->is(TT_LineComment))
634 return 0;
635
636 // Check for Limit <= 2 to account for the " {".
637 if (Limit <= 2 || (Style.ColumnLimit == 0 && containsMustBreak(*I)))
638 return 0;
639 Limit -= 2;
640 unsigned MergedLines = 0;
641 if (Style.AllowShortBlocksOnASingleLine != FormatStyle::SBS_Never ||
642 (I[1]->First == I[1]->Last && I + 2 != E &&
643 I[2]->First->is(tok::r_brace))) {
644 MergedLines = tryMergeSimpleBlock(I + 1, E, Limit);
645 // If we managed to merge the block, count the statement header, which
646 // is on a separate line.
647 if (MergedLines > 0)
648 ++MergedLines;
649 }
650 return MergedLines;
651 }
652 return 0;
653 }
654
655 /// Returns the modified column limit for \p I if it is inside a macro and
656 /// needs a trailing '\'.
657 unsigned
658 limitConsideringMacros(SmallVectorImpl<AnnotatedLine *>::const_iterator I,
659 SmallVectorImpl<AnnotatedLine *>::const_iterator E,
660 unsigned Limit) {
661 if (I[0]->InPPDirective && I + 1 != E &&
662 !I[1]->First->HasUnescapedNewline && !I[1]->First->is(tok::eof)) {
663 return Limit < 2 ? 0 : Limit - 2;
664 }
665 return Limit;
666 }
667
668 bool nextTwoLinesFitInto(SmallVectorImpl<AnnotatedLine *>::const_iterator I,
669 unsigned Limit) {
670 if (I[1]->First->MustBreakBefore || I[2]->First->MustBreakBefore)
671 return false;
672 return 1 + I[1]->Last->TotalLength + 1 + I[2]->Last->TotalLength <= Limit;
673 }
674
675 bool containsMustBreak(const AnnotatedLine *Line) {
676 for (const FormatToken *Tok = Line->First; Tok; Tok = Tok->Next) {
677 if (Tok->MustBreakBefore)
678 return true;
679 }
680 return false;
681 }
682
683 void join(AnnotatedLine &A, const AnnotatedLine &B) {
684 assert(!A.Last->Next)((!A.Last->Next) ? static_cast<void> (0) : __assert_fail
("!A.Last->Next", "/build/llvm-toolchain-snapshot-10~svn374877/tools/clang/lib/Format/UnwrappedLineFormatter.cpp"
, 684, __PRETTY_FUNCTION__))
;
685 assert(!B.First->Previous)((!B.First->Previous) ? static_cast<void> (0) : __assert_fail
("!B.First->Previous", "/build/llvm-toolchain-snapshot-10~svn374877/tools/clang/lib/Format/UnwrappedLineFormatter.cpp"
, 685, __PRETTY_FUNCTION__))
;
686 if (B.Affected)
687 A.Affected = true;
688 A.Last->Next = B.First;
689 B.First->Previous = A.Last;
690 B.First->CanBreakBefore = true;
691 unsigned LengthA = A.Last->TotalLength + B.First->SpacesRequiredBefore;
692 for (FormatToken *Tok = B.First; Tok; Tok = Tok->Next) {
693 Tok->TotalLength += LengthA;
694 A.Last = Tok;
695 }
696 }
697
698 const FormatStyle &Style;
699 const AdditionalKeywords &Keywords;
700 const SmallVectorImpl<AnnotatedLine *>::const_iterator End;
701
702 SmallVectorImpl<AnnotatedLine *>::const_iterator Next;
703 const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines;
704};
705
706static void markFinalized(FormatToken *Tok) {
707 for (; Tok; Tok = Tok->Next) {
708 Tok->Finalized = true;
709 for (AnnotatedLine *Child : Tok->Children)
710 markFinalized(Child->First);
711 }
712}
713
714#ifndef NDEBUG
715static void printLineState(const LineState &State) {
716 llvm::dbgs() << "State: ";
717 for (const ParenState &P : State.Stack) {
718 llvm::dbgs() << (P.Tok ? P.Tok->TokenText : "F") << "|" << P.Indent << "|"
719 << P.LastSpace << "|" << P.NestedBlockIndent << " ";
720 }
721 llvm::dbgs() << State.NextToken->TokenText << "\n";
722}
723#endif
724
725/// Base class for classes that format one \c AnnotatedLine.
726class LineFormatter {
727public:
728 LineFormatter(ContinuationIndenter *Indenter, WhitespaceManager *Whitespaces,
729 const FormatStyle &Style,
730 UnwrappedLineFormatter *BlockFormatter)
731 : Indenter(Indenter), Whitespaces(Whitespaces), Style(Style),
732 BlockFormatter(BlockFormatter) {}
733 virtual ~LineFormatter() {}
734
735 /// Formats an \c AnnotatedLine and returns the penalty.
736 ///
737 /// If \p DryRun is \c false, directly applies the changes.
738 virtual unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
739 unsigned FirstStartColumn, bool DryRun) = 0;
740
741protected:
742 /// If the \p State's next token is an r_brace closing a nested block,
743 /// format the nested block before it.
744 ///
745 /// Returns \c true if all children could be placed successfully and adapts
746 /// \p Penalty as well as \p State. If \p DryRun is false, also directly
747 /// creates changes using \c Whitespaces.
748 ///
749 /// The crucial idea here is that children always get formatted upon
750 /// encountering the closing brace right after the nested block. Now, if we
751 /// are currently trying to keep the "}" on the same line (i.e. \p NewLine is
752 /// \c false), the entire block has to be kept on the same line (which is only
753 /// possible if it fits on the line, only contains a single statement, etc.
754 ///
755 /// If \p NewLine is true, we format the nested block on separate lines, i.e.
756 /// break after the "{", format all lines with correct indentation and the put
757 /// the closing "}" on yet another new line.
758 ///
759 /// This enables us to keep the simple structure of the
760 /// \c UnwrappedLineFormatter, where we only have two options for each token:
761 /// break or don't break.
762 bool formatChildren(LineState &State, bool NewLine, bool DryRun,
763 unsigned &Penalty) {
764 const FormatToken *LBrace = State.NextToken->getPreviousNonComment();
765 FormatToken &Previous = *State.NextToken->Previous;
766 if (!LBrace
0.1
'LBrace' is non-null
|| LBrace->isNot(tok::l_brace) ||
3
Taking false branch
767 LBrace->BlockKind != BK_Block || Previous.Children.size() == 0)
1
Assuming field 'BlockKind' is equal to BK_Block
2
Assuming the condition is false
768 // The previous token does not open a block. Nothing to do. We don't
769 // assert so that we can simply call this function for all tokens.
770 return true;
771
772 if (NewLine) {
4
Assuming 'NewLine' is true
5
Taking true branch
773 int AdditionalIndent = State.Stack.back().Indent -
774 Previous.Children[0]->Level * Style.IndentWidth;
775
776 Penalty +=
777 BlockFormatter->format(Previous.Children, DryRun, AdditionalIndent,
6
Calling 'UnwrappedLineFormatter::format'
778 /*FixBadIndentation=*/true);
779 return true;
780 }
781
782 if (Previous.Children[0]->First->MustBreakBefore)
783 return false;
784
785 // Cannot merge into one line if this line ends on a comment.
786 if (Previous.is(tok::comment))
787 return false;
788
789 // Cannot merge multiple statements into a single line.
790 if (Previous.Children.size() > 1)
791 return false;
792
793 const AnnotatedLine *Child = Previous.Children[0];
794 // We can't put the closing "}" on a line with a trailing comment.
795 if (Child->Last->isTrailingComment())
796 return false;
797
798 // If the child line exceeds the column limit, we wouldn't want to merge it.
799 // We add +2 for the trailing " }".
800 if (Style.ColumnLimit > 0 &&
801 Child->Last->TotalLength + State.Column + 2 > Style.ColumnLimit)
802 return false;
803
804 if (!DryRun) {
805 Whitespaces->replaceWhitespace(
806 *Child->First, /*Newlines=*/0, /*Spaces=*/1,
807 /*StartOfTokenColumn=*/State.Column, State.Line->InPPDirective);
808 }
809 Penalty +=
810 formatLine(*Child, State.Column + 1, /*FirstStartColumn=*/0, DryRun);
811
812 State.Column += 1 + Child->Last->TotalLength;
813 return true;
814 }
815
816 ContinuationIndenter *Indenter;
817
818private:
819 WhitespaceManager *Whitespaces;
820 const FormatStyle &Style;
821 UnwrappedLineFormatter *BlockFormatter;
822};
823
824/// Formatter that keeps the existing line breaks.
825class NoColumnLimitLineFormatter : public LineFormatter {
826public:
827 NoColumnLimitLineFormatter(ContinuationIndenter *Indenter,
828 WhitespaceManager *Whitespaces,
829 const FormatStyle &Style,
830 UnwrappedLineFormatter *BlockFormatter)
831 : LineFormatter(Indenter, Whitespaces, Style, BlockFormatter) {}
832
833 /// Formats the line, simply keeping all of the input's line breaking
834 /// decisions.
835 unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
836 unsigned FirstStartColumn, bool DryRun) override {
837 assert(!DryRun)((!DryRun) ? static_cast<void> (0) : __assert_fail ("!DryRun"
, "/build/llvm-toolchain-snapshot-10~svn374877/tools/clang/lib/Format/UnwrappedLineFormatter.cpp"
, 837, __PRETTY_FUNCTION__))
;
838 LineState State = Indenter->getInitialState(FirstIndent, FirstStartColumn,
839 &Line, /*DryRun=*/false);
840 while (State.NextToken) {
841 bool Newline =
842 Indenter->mustBreak(State) ||
843 (Indenter->canBreak(State) && State.NextToken->NewlinesBefore > 0);
844 unsigned Penalty = 0;
845 formatChildren(State, Newline, /*DryRun=*/false, Penalty);
846 Indenter->addTokenToState(State, Newline, /*DryRun=*/false);
847 }
848 return 0;
849 }
850};
851
852/// Formatter that puts all tokens into a single line without breaks.
853class NoLineBreakFormatter : public LineFormatter {
854public:
855 NoLineBreakFormatter(ContinuationIndenter *Indenter,
856 WhitespaceManager *Whitespaces, const FormatStyle &Style,
857 UnwrappedLineFormatter *BlockFormatter)
858 : LineFormatter(Indenter, Whitespaces, Style, BlockFormatter) {}
859
860 /// Puts all tokens into a single line.
861 unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
862 unsigned FirstStartColumn, bool DryRun) override {
863 unsigned Penalty = 0;
864 LineState State =
865 Indenter->getInitialState(FirstIndent, FirstStartColumn, &Line, DryRun);
866 while (State.NextToken) {
867 formatChildren(State, /*NewLine=*/false, DryRun, Penalty);
868 Indenter->addTokenToState(
869 State, /*Newline=*/State.NextToken->MustBreakBefore, DryRun);
870 }
871 return Penalty;
872 }
873};
874
875/// Finds the best way to break lines.
876class OptimizingLineFormatter : public LineFormatter {
877public:
878 OptimizingLineFormatter(ContinuationIndenter *Indenter,
879 WhitespaceManager *Whitespaces,
880 const FormatStyle &Style,
881 UnwrappedLineFormatter *BlockFormatter)
882 : LineFormatter(Indenter, Whitespaces, Style, BlockFormatter) {}
883
884 /// Formats the line by finding the best line breaks with line lengths
885 /// below the column limit.
886 unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
887 unsigned FirstStartColumn, bool DryRun) override {
888 LineState State =
889 Indenter->getInitialState(FirstIndent, FirstStartColumn, &Line, DryRun);
890
891 // If the ObjC method declaration does not fit on a line, we should format
892 // it with one arg per line.
893 if (State.Line->Type == LT_ObjCMethodDecl)
894 State.Stack.back().BreakBeforeParameter = true;
895
896 // Find best solution in solution space.
897 return analyzeSolutionSpace(State, DryRun);
898 }
899
900private:
901 struct CompareLineStatePointers {
902 bool operator()(LineState *obj1, LineState *obj2) const {
903 return *obj1 < *obj2;
904 }
905 };
906
907 /// A pair of <penalty, count> that is used to prioritize the BFS on.
908 ///
909 /// In case of equal penalties, we want to prefer states that were inserted
910 /// first. During state generation we make sure that we insert states first
911 /// that break the line as late as possible.
912 typedef std::pair<unsigned, unsigned> OrderedPenalty;
913
914 /// An edge in the solution space from \c Previous->State to \c State,
915 /// inserting a newline dependent on the \c NewLine.
916 struct StateNode {
917 StateNode(const LineState &State, bool NewLine, StateNode *Previous)
918 : State(State), NewLine(NewLine), Previous(Previous) {}
919 LineState State;
920 bool NewLine;
921 StateNode *Previous;
922 };
923
924 /// An item in the prioritized BFS search queue. The \c StateNode's
925 /// \c State has the given \c OrderedPenalty.
926 typedef std::pair<OrderedPenalty, StateNode *> QueueItem;
927
928 /// The BFS queue type.
929 typedef std::priority_queue<QueueItem, std::vector<QueueItem>,
930 std::greater<QueueItem>>
931 QueueType;
932
933 /// Analyze the entire solution space starting from \p InitialState.
934 ///
935 /// This implements a variant of Dijkstra's algorithm on the graph that spans
936 /// the solution space (\c LineStates are the nodes). The algorithm tries to
937 /// find the shortest path (the one with lowest penalty) from \p InitialState
938 /// to a state where all tokens are placed. Returns the penalty.
939 ///
940 /// If \p DryRun is \c false, directly applies the changes.
941 unsigned analyzeSolutionSpace(LineState &InitialState, bool DryRun) {
942 std::set<LineState *, CompareLineStatePointers> Seen;
943
944 // Increasing count of \c StateNode items we have created. This is used to
945 // create a deterministic order independent of the container.
946 unsigned Count = 0;
947 QueueType Queue;
948
949 // Insert start element into queue.
950 StateNode *Node =
951 new (Allocator.Allocate()) StateNode(InitialState, false, nullptr);
952 Queue.push(QueueItem(OrderedPenalty(0, Count), Node));
953 ++Count;
954
955 unsigned Penalty = 0;
956
957 // While not empty, take first element and follow edges.
958 while (!Queue.empty()) {
959 Penalty = Queue.top().first.first;
960 StateNode *Node = Queue.top().second;
961 if (!Node->State.NextToken) {
962 LLVM_DEBUG(llvm::dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "\n---\nPenalty for line: "
<< Penalty << "\n"; } } while (false)
963 << "\n---\nPenalty for line: " << Penalty << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "\n---\nPenalty for line: "
<< Penalty << "\n"; } } while (false)
;
964 break;
965 }
966 Queue.pop();
967
968 // Cut off the analysis of certain solutions if the analysis gets too
969 // complex. See description of IgnoreStackForComparison.
970 if (Count > 50000)
971 Node->State.IgnoreStackForComparison = true;
972
973 if (!Seen.insert(&Node->State).second)
974 // State already examined with lower penalty.
975 continue;
976
977 FormatDecision LastFormat = Node->State.NextToken->Decision;
978 if (LastFormat == FD_Unformatted || LastFormat == FD_Continue)
979 addNextStateToQueue(Penalty, Node, /*NewLine=*/false, &Count, &Queue);
980 if (LastFormat == FD_Unformatted || LastFormat == FD_Break)
981 addNextStateToQueue(Penalty, Node, /*NewLine=*/true, &Count, &Queue);
982 }
983
984 if (Queue.empty()) {
985 // We were unable to find a solution, do nothing.
986 // FIXME: Add diagnostic?
987 LLVM_DEBUG(llvm::dbgs() << "Could not find a solution.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Could not find a solution.\n"
; } } while (false)
;
988 return 0;
989 }
990
991 // Reconstruct the solution.
992 if (!DryRun)
993 reconstructPath(InitialState, Queue.top().second);
994
995 LLVM_DEBUG(llvm::dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Total number of analyzed states: "
<< Count << "\n"; } } while (false)
996 << "Total number of analyzed states: " << Count << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Total number of analyzed states: "
<< Count << "\n"; } } while (false)
;
997 LLVM_DEBUG(llvm::dbgs() << "---\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "---\n"; } } while
(false)
;
998
999 return Penalty;
1000 }
1001
1002 /// Add the following state to the analysis queue \c Queue.
1003 ///
1004 /// Assume the current state is \p PreviousNode and has been reached with a
1005 /// penalty of \p Penalty. Insert a line break if \p NewLine is \c true.
1006 void addNextStateToQueue(unsigned Penalty, StateNode *PreviousNode,
1007 bool NewLine, unsigned *Count, QueueType *Queue) {
1008 if (NewLine && !Indenter->canBreak(PreviousNode->State))
1009 return;
1010 if (!NewLine && Indenter->mustBreak(PreviousNode->State))
1011 return;
1012
1013 StateNode *Node = new (Allocator.Allocate())
1014 StateNode(PreviousNode->State, NewLine, PreviousNode);
1015 if (!formatChildren(Node->State, NewLine, /*DryRun=*/true, Penalty))
1016 return;
1017
1018 Penalty += Indenter->addTokenToState(Node->State, NewLine, true);
1019
1020 Queue->push(QueueItem(OrderedPenalty(Penalty, *Count), Node));
1021 ++(*Count);
1022 }
1023
1024 /// Applies the best formatting by reconstructing the path in the
1025 /// solution space that leads to \c Best.
1026 void reconstructPath(LineState &State, StateNode *Best) {
1027 std::deque<StateNode *> Path;
1028 // We do not need a break before the initial token.
1029 while (Best->Previous) {
1030 Path.push_front(Best);
1031 Best = Best->Previous;
1032 }
1033 for (auto I = Path.begin(), E = Path.end(); I != E; ++I) {
1034 unsigned Penalty = 0;
1035 formatChildren(State, (*I)->NewLine, /*DryRun=*/false, Penalty);
1036 Penalty += Indenter->addTokenToState(State, (*I)->NewLine, false);
1037
1038 LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { { printLineState((*I)->Previous->
State); if ((*I)->NewLine) { llvm::dbgs() << "Penalty for placing "
<< (*I)->Previous->State.NextToken->Tok.getName
() << " on a new line: " << Penalty << "\n"
; } }; } } while (false)
1039 printLineState((*I)->Previous->State);do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { { printLineState((*I)->Previous->
State); if ((*I)->NewLine) { llvm::dbgs() << "Penalty for placing "
<< (*I)->Previous->State.NextToken->Tok.getName
() << " on a new line: " << Penalty << "\n"
; } }; } } while (false)
1040 if ((*I)->NewLine) {do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { { printLineState((*I)->Previous->
State); if ((*I)->NewLine) { llvm::dbgs() << "Penalty for placing "
<< (*I)->Previous->State.NextToken->Tok.getName
() << " on a new line: " << Penalty << "\n"
; } }; } } while (false)
1041 llvm::dbgs() << "Penalty for placing "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { { printLineState((*I)->Previous->
State); if ((*I)->NewLine) { llvm::dbgs() << "Penalty for placing "
<< (*I)->Previous->State.NextToken->Tok.getName
() << " on a new line: " << Penalty << "\n"
; } }; } } while (false)
1042 << (*I)->Previous->State.NextToken->Tok.getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { { printLineState((*I)->Previous->
State); if ((*I)->NewLine) { llvm::dbgs() << "Penalty for placing "
<< (*I)->Previous->State.NextToken->Tok.getName
() << " on a new line: " << Penalty << "\n"
; } }; } } while (false)
1043 << " on a new line: " << Penalty << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { { printLineState((*I)->Previous->
State); if ((*I)->NewLine) { llvm::dbgs() << "Penalty for placing "
<< (*I)->Previous->State.NextToken->Tok.getName
() << " on a new line: " << Penalty << "\n"
; } }; } } while (false)
1044 }do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { { printLineState((*I)->Previous->
State); if ((*I)->NewLine) { llvm::dbgs() << "Penalty for placing "
<< (*I)->Previous->State.NextToken->Tok.getName
() << " on a new line: " << Penalty << "\n"
; } }; } } while (false)
1045 })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { { printLineState((*I)->Previous->
State); if ((*I)->NewLine) { llvm::dbgs() << "Penalty for placing "
<< (*I)->Previous->State.NextToken->Tok.getName
() << " on a new line: " << Penalty << "\n"
; } }; } } while (false)
;
1046 }
1047 }
1048
1049 llvm::SpecificBumpPtrAllocator<StateNode> Allocator;
1050};
1051
1052} // anonymous namespace
1053
1054unsigned UnwrappedLineFormatter::format(
1055 const SmallVectorImpl<AnnotatedLine *> &Lines, bool DryRun,
1056 int AdditionalIndent, bool FixBadIndentation, unsigned FirstStartColumn,
1057 unsigned NextStartColumn, unsigned LastStartColumn) {
1058 LineJoiner Joiner(Style, Keywords, Lines);
1059
1060 // Try to look up already computed penalty in DryRun-mode.
1061 std::pair<const SmallVectorImpl<AnnotatedLine *> *, unsigned> CacheKey(
1062 &Lines, AdditionalIndent);
1063 auto CacheIt = PenaltyCache.find(CacheKey);
1064 if (DryRun
18.1
'DryRun' is false
36.1
'DryRun' is false
&& CacheIt != PenaltyCache.end())
7
Assuming 'DryRun' is false
8
Taking false branch
19
Taking false branch
37
Taking false branch
1065 return CacheIt->second;
1066
1067 assert(!Lines.empty())((!Lines.empty()) ? static_cast<void> (0) : __assert_fail
("!Lines.empty()", "/build/llvm-toolchain-snapshot-10~svn374877/tools/clang/lib/Format/UnwrappedLineFormatter.cpp"
, 1067, __PRETTY_FUNCTION__))
;
9
'?' condition is true
20
'?' condition is true
38
'?' condition is true
1068 unsigned Penalty = 0;
1069 LevelIndentTracker IndentTracker(Style, Keywords, Lines[0]->Level,
1070 AdditionalIndent);
1071 const AnnotatedLine *PreviousLine = nullptr;
1072 const AnnotatedLine *NextLine = nullptr;
1073
1074 // The minimum level of consecutive lines that have been formatted.
1075 unsigned RangeMinLevel = UINT_MAX(2147483647 *2U +1U);
1076
1077 bool FirstLine = true;
1078 for (const AnnotatedLine *Line =
10
Loop condition is true. Entering loop body
29
Loop condition is true. Entering loop body
47
Loop condition is true. Entering loop body
1079 Joiner.getNextMergedLine(DryRun, IndentTracker);
21
Calling 'LineJoiner::getNextMergedLine'
28
Returning from 'LineJoiner::getNextMergedLine'
39
Calling 'LineJoiner::getNextMergedLine'
46
Returning from 'LineJoiner::getNextMergedLine'
1080 Line; Line = NextLine, FirstLine = false) {
1081 const AnnotatedLine &TheLine = *Line;
1082 unsigned Indent = IndentTracker.getIndent();
1083
1084 // We continue formatting unchanged lines to adjust their indent, e.g. if a
1085 // scope was added. However, we need to carefully stop doing this when we
1086 // exit the scope of affected lines to prevent indenting a the entire
1087 // remaining file if it currently missing a closing brace.
1088 bool PreviousRBrace =
1089 PreviousLine
10.1
'PreviousLine' is null
29.1
'PreviousLine' is null
47.1
'PreviousLine' is null
&& PreviousLine->startsWith(tok::r_brace);
1090 bool ContinueFormatting =
1091 TheLine.Level > RangeMinLevel
10.2
'RangeMinLevel' is >= field 'Level'
29.2
'RangeMinLevel' is >= field 'Level'
47.2
'RangeMinLevel' is >= field 'Level'
||
1092 (TheLine.Level == RangeMinLevel && !PreviousRBrace &&
11
Assuming 'RangeMinLevel' is not equal to field 'Level'
30
Assuming 'RangeMinLevel' is not equal to field 'Level'
48
Assuming 'RangeMinLevel' is not equal to field 'Level'
1093 !TheLine.startsWith(tok::r_brace));
1094
1095 bool FixIndentation = (FixBadIndentation
11.1
'FixBadIndentation' is true
30.1
'FixBadIndentation' is false
48.1
'FixBadIndentation' is false
|| ContinueFormatting
30.2
'ContinueFormatting' is false
48.2
'ContinueFormatting' is false
) &&
1096 Indent != TheLine.First->OriginalColumn;
12
Assuming 'Indent' is equal to field 'OriginalColumn'
1097 bool ShouldFormat = TheLine.Affected || FixIndentation;
13
Assuming field 'Affected' is false
31
Assuming field 'Affected' is false
49
Assuming field 'Affected' is false
1098 // We cannot format this line; if the reason is that the line had a
1099 // parsing error, remember that.
1100 if (ShouldFormat
13.1
'ShouldFormat' is false
31.1
'ShouldFormat' is false
49.1
'ShouldFormat' is false
&& TheLine.Type == LT_Invalid && Status) {
1101 Status->FormatComplete = false;
1102 Status->Line =
1103 SourceMgr.getSpellingLineNumber(TheLine.First->Tok.getLocation());
1104 }
1105
1106 if (ShouldFormat
13.2
'ShouldFormat' is false
31.2
'ShouldFormat' is false
49.2
'ShouldFormat' is false
&& TheLine.Type != LT_Invalid) {
1107 if (!DryRun) {
1108 bool LastLine = Line->First->is(tok::eof);
1109 formatFirstToken(TheLine, PreviousLine, Lines, Indent,
1110 LastLine ? LastStartColumn : NextStartColumn + Indent);
1111 }
1112
1113 NextLine = Joiner.getNextMergedLine(DryRun, IndentTracker);
1114 unsigned ColumnLimit = getColumnLimit(TheLine.InPPDirective, NextLine);
1115 bool FitsIntoOneLine =
1116 TheLine.Last->TotalLength + Indent <= ColumnLimit ||
1117 (TheLine.Type == LT_ImportStatement &&
1118 (Style.Language != FormatStyle::LK_JavaScript ||
1119 !Style.JavaScriptWrapImports)) ||
1120 (Style.isCSharp() &&
1121 TheLine.InPPDirective); // don't split #regions in C#
1122 if (Style.ColumnLimit == 0)
1123 NoColumnLimitLineFormatter(Indenter, Whitespaces, Style, this)
1124 .formatLine(TheLine, NextStartColumn + Indent,
1125 FirstLine ? FirstStartColumn : 0, DryRun);
1126 else if (FitsIntoOneLine)
1127 Penalty += NoLineBreakFormatter(Indenter, Whitespaces, Style, this)
1128 .formatLine(TheLine, NextStartColumn + Indent,
1129 FirstLine ? FirstStartColumn : 0, DryRun);
1130 else
1131 Penalty += OptimizingLineFormatter(Indenter, Whitespaces, Style, this)
1132 .formatLine(TheLine, NextStartColumn + Indent,
1133 FirstLine ? FirstStartColumn : 0, DryRun);
1134 RangeMinLevel = std::min(RangeMinLevel, TheLine.Level);
1135 } else {
1136 // If no token in the current line is affected, we still need to format
1137 // affected children.
1138 if (TheLine.ChildrenAffected)
14
Assuming field 'ChildrenAffected' is true
15
Taking true branch
32
Assuming field 'ChildrenAffected' is true
33
Taking true branch
50
Assuming field 'ChildrenAffected' is true
51
Taking true branch
1139 for (const FormatToken *Tok = TheLine.First; Tok; Tok = Tok->Next)
16
Loop condition is true. Entering loop body
34
Loop condition is true. Entering loop body
52
Assuming pointer value is null
53
Loop condition is false. Execution continues on line 1146
1140 if (!Tok->Children.empty())
17
Taking true branch
35
Taking true branch
1141 format(Tok->Children, DryRun);
18
Calling 'UnwrappedLineFormatter::format'
36
Calling 'UnwrappedLineFormatter::format'
1142
1143 // Adapt following lines on the current indent level to the same level
1144 // unless the current \c AnnotatedLine is not at the beginning of a line.
1145 bool StartsNewLine =
1146 TheLine.First->NewlinesBefore > 0 || TheLine.First->IsFirst;
54
Access to field 'NewlinesBefore' results in a dereference of a null pointer (loaded from field 'First')
1147 if (StartsNewLine)
1148 IndentTracker.adjustToUnmodifiedLine(TheLine);
1149 if (!DryRun) {
1150 bool ReformatLeadingWhitespace =
1151 StartsNewLine && ((PreviousLine && PreviousLine->Affected) ||
1152 TheLine.LeadingEmptyLinesAffected);
1153 // Format the first token.
1154 if (ReformatLeadingWhitespace)
1155 formatFirstToken(TheLine, PreviousLine, Lines,
1156 TheLine.First->OriginalColumn,
1157 TheLine.First->OriginalColumn);
1158 else
1159 Whitespaces->addUntouchableToken(*TheLine.First,
1160 TheLine.InPPDirective);
1161
1162 // Notify the WhitespaceManager about the unchanged whitespace.
1163 for (FormatToken *Tok = TheLine.First->Next; Tok; Tok = Tok->Next)
1164 Whitespaces->addUntouchableToken(*Tok, TheLine.InPPDirective);
1165 }
1166 NextLine = Joiner.getNextMergedLine(DryRun, IndentTracker);
1167 RangeMinLevel = UINT_MAX(2147483647 *2U +1U);
1168 }
1169 if (!DryRun)
1170 markFinalized(TheLine.First);
1171 PreviousLine = &TheLine;
1172 }
1173 PenaltyCache[CacheKey] = Penalty;
1174 return Penalty;
1175}
1176
1177void UnwrappedLineFormatter::formatFirstToken(
1178 const AnnotatedLine &Line, const AnnotatedLine *PreviousLine,
1179 const SmallVectorImpl<AnnotatedLine *> &Lines, unsigned Indent,
1180 unsigned NewlineIndent) {
1181 FormatToken &RootToken = *Line.First;
1182 if (RootToken.is(tok::eof)) {
1183 unsigned Newlines = std::min(RootToken.NewlinesBefore, 1u);
1184 unsigned TokenIndent = Newlines ? NewlineIndent : 0;
1185 Whitespaces->replaceWhitespace(RootToken, Newlines, TokenIndent,
1186 TokenIndent);
1187 return;
1188 }
1189 unsigned Newlines =
1190 std::min(RootToken.NewlinesBefore, Style.MaxEmptyLinesToKeep + 1);
1191 // Remove empty lines before "}" where applicable.
1192 if (RootToken.is(tok::r_brace) &&
1193 (!RootToken.Next ||
1194 (RootToken.Next->is(tok::semi) && !RootToken.Next->Next)) &&
1195 // Do not remove empty lines before namespace closing "}".
1196 !getNamespaceToken(&Line, Lines))
1197 Newlines = std::min(Newlines, 1u);
1198 // Remove empty lines at the start of nested blocks (lambdas/arrow functions)
1199 if (PreviousLine == nullptr && Line.Level > 0)
1200 Newlines = std::min(Newlines, 1u);
1201 if (Newlines == 0 && !RootToken.IsFirst)
1202 Newlines = 1;
1203 if (RootToken.IsFirst && !RootToken.HasUnescapedNewline)
1204 Newlines = 0;
1205
1206 // Remove empty lines after "{".
1207 if (!Style.KeepEmptyLinesAtTheStartOfBlocks && PreviousLine &&
1208 PreviousLine->Last->is(tok::l_brace) &&
1209 !PreviousLine->startsWithNamespace() &&
1210 !startsExternCBlock(*PreviousLine))
1211 Newlines = 1;
1212
1213 // Insert extra new line before access specifiers.
1214 if (PreviousLine && PreviousLine->Last->isOneOf(tok::semi, tok::r_brace) &&
1215 RootToken.isAccessSpecifier() && RootToken.NewlinesBefore == 1)
1216 ++Newlines;
1217
1218 // Remove empty lines after access specifiers.
1219 if (PreviousLine && PreviousLine->First->isAccessSpecifier() &&
1220 (!PreviousLine->InPPDirective || !RootToken.HasUnescapedNewline))
1221 Newlines = std::min(1u, Newlines);
1222
1223 if (Newlines)
1224 Indent = NewlineIndent;
1225
1226 // If in Whitemsmiths mode, indent start and end of blocks
1227 if (Style.BreakBeforeBraces == FormatStyle::BS_Whitesmiths) {
1228 if (RootToken.isOneOf(tok::l_brace, tok::r_brace, tok::kw_case))
1229 Indent += Style.IndentWidth;
1230 }
1231
1232 // Preprocessor directives get indented before the hash only if specified
1233 if (Style.IndentPPDirectives != FormatStyle::PPDIS_BeforeHash &&
1234 (Line.Type == LT_PreprocessorDirective ||
1235 Line.Type == LT_ImportStatement))
1236 Indent = 0;
1237
1238 Whitespaces->replaceWhitespace(RootToken, Newlines, Indent, Indent,
1239 Line.InPPDirective &&
1240 !RootToken.HasUnescapedNewline);
1241}
1242
1243unsigned
1244UnwrappedLineFormatter::getColumnLimit(bool InPPDirective,
1245 const AnnotatedLine *NextLine) const {
1246 // In preprocessor directives reserve two chars for trailing " \" if the
1247 // next line continues the preprocessor directive.
1248 bool ContinuesPPDirective =
1249 InPPDirective &&
1250 // If there is no next line, this is likely a child line and the parent
1251 // continues the preprocessor directive.
1252 (!NextLine ||
1253 (NextLine->InPPDirective &&
1254 // If there is an unescaped newline between this line and the next, the
1255 // next line starts a new preprocessor directive.
1256 !NextLine->First->HasUnescapedNewline));
1257 return Style.ColumnLimit - (ContinuesPPDirective ? 2 : 0);
1258}
1259
1260} // namespace format
1261} // namespace clang