Bug Summary

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