Coverage Report

Created: 2022-07-16 07:03

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Format/ContinuationIndenter.h
Line
Count
Source (jump to first uncovered line)
1
//===--- ContinuationIndenter.h - Format C++ code ---------------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
///
9
/// \file
10
/// This file implements an indenter that manages the indentation of
11
/// continuations.
12
///
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CLANG_LIB_FORMAT_CONTINUATIONINDENTER_H
16
#define LLVM_CLANG_LIB_FORMAT_CONTINUATIONINDENTER_H
17
18
#include "Encoding.h"
19
#include "FormatToken.h"
20
#include "clang/Format/Format.h"
21
#include "llvm/Support/Regex.h"
22
#include <map>
23
#include <tuple>
24
25
namespace clang {
26
class SourceManager;
27
28
namespace format {
29
30
class AnnotatedLine;
31
class BreakableToken;
32
struct FormatToken;
33
struct LineState;
34
struct ParenState;
35
struct RawStringFormatStyleManager;
36
class WhitespaceManager;
37
38
struct RawStringFormatStyleManager {
39
  llvm::StringMap<FormatStyle> DelimiterStyle;
40
  llvm::StringMap<FormatStyle> EnclosingFunctionStyle;
41
42
  RawStringFormatStyleManager(const FormatStyle &CodeStyle);
43
44
  llvm::Optional<FormatStyle> getDelimiterStyle(StringRef Delimiter) const;
45
46
  llvm::Optional<FormatStyle>
47
  getEnclosingFunctionStyle(StringRef EnclosingFunction) const;
48
};
49
50
class ContinuationIndenter {
51
public:
52
  /// Constructs a \c ContinuationIndenter to format \p Line starting in
53
  /// column \p FirstIndent.
54
  ContinuationIndenter(const FormatStyle &Style,
55
                       const AdditionalKeywords &Keywords,
56
                       const SourceManager &SourceMgr,
57
                       WhitespaceManager &Whitespaces,
58
                       encoding::Encoding Encoding,
59
                       bool BinPackInconclusiveFunctions);
60
61
  /// Get the initial state, i.e. the state after placing \p Line's
62
  /// first token at \p FirstIndent. When reformatting a fragment of code, as in
63
  /// the case of formatting inside raw string literals, \p FirstStartColumn is
64
  /// the column at which the state of the parent formatter is.
65
  LineState getInitialState(unsigned FirstIndent, unsigned FirstStartColumn,
66
                            const AnnotatedLine *Line, bool DryRun);
67
68
  // FIXME: canBreak and mustBreak aren't strictly indentation-related. Find a
69
  // better home.
70
  /// Returns \c true, if a line break after \p State is allowed.
71
  bool canBreak(const LineState &State);
72
73
  /// Returns \c true, if a line break after \p State is mandatory.
74
  bool mustBreak(const LineState &State);
75
76
  /// Appends the next token to \p State and updates information
77
  /// necessary for indentation.
78
  ///
79
  /// Puts the token on the current line if \p Newline is \c false and adds a
80
  /// line break and necessary indentation otherwise.
81
  ///
82
  /// If \p DryRun is \c false, also creates and stores the required
83
  /// \c Replacement.
84
  unsigned addTokenToState(LineState &State, bool Newline, bool DryRun,
85
                           unsigned ExtraSpaces = 0);
86
87
  /// Get the column limit for this line. This is the style's column
88
  /// limit, potentially reduced for preprocessor definitions.
89
  unsigned getColumnLimit(const LineState &State) const;
90
91
private:
92
  /// Mark the next token as consumed in \p State and modify its stacks
93
  /// accordingly.
94
  unsigned moveStateToNextToken(LineState &State, bool DryRun, bool Newline);
95
96
  /// Update 'State' according to the next token's fake left parentheses.
97
  void moveStatePastFakeLParens(LineState &State, bool Newline);
98
  /// Update 'State' according to the next token's fake r_parens.
99
  void moveStatePastFakeRParens(LineState &State);
100
101
  /// Update 'State' according to the next token being one of "(<{[".
102
  void moveStatePastScopeOpener(LineState &State, bool Newline);
103
  /// Update 'State' according to the next token being one of ")>}]".
104
  void moveStatePastScopeCloser(LineState &State);
105
  /// Update 'State' with the next token opening a nested block.
106
  void moveStateToNewBlock(LineState &State);
107
108
  /// Reformats a raw string literal.
109
  ///
110
  /// \returns An extra penalty induced by reformatting the token.
111
  unsigned reformatRawStringLiteral(const FormatToken &Current,
112
                                    LineState &State,
113
                                    const FormatStyle &RawStringStyle,
114
                                    bool DryRun, bool Newline);
115
116
  /// If the current token is at the end of the current line, handle
117
  /// the transition to the next line.
118
  unsigned handleEndOfLine(const FormatToken &Current, LineState &State,
119
                           bool DryRun, bool AllowBreak, bool Newline);
120
121
  /// If \p Current is a raw string that is configured to be reformatted,
122
  /// return the style to be used.
123
  llvm::Optional<FormatStyle> getRawStringStyle(const FormatToken &Current,
124
                                                const LineState &State);
125
126
  /// If the current token sticks out over the end of the line, break
127
  /// it if possible.
128
  ///
129
  /// \returns A pair (penalty, exceeded), where penalty is the extra penalty
130
  /// when tokens are broken or lines exceed the column limit, and exceeded
131
  /// indicates whether the algorithm purposefully left lines exceeding the
132
  /// column limit.
133
  ///
134
  /// The returned penalty will cover the cost of the additional line breaks
135
  /// and column limit violation in all lines except for the last one. The
136
  /// penalty for the column limit violation in the last line (and in single
137
  /// line tokens) is handled in \c addNextStateToQueue.
138
  ///
139
  /// \p Strict indicates whether reflowing is allowed to leave characters
140
  /// protruding the column limit; if true, lines will be split strictly within
141
  /// the column limit where possible; if false, words are allowed to protrude
142
  /// over the column limit as long as the penalty is less than the penalty
143
  /// of a break.
144
  std::pair<unsigned, bool> breakProtrudingToken(const FormatToken &Current,
145
                                                 LineState &State,
146
                                                 bool AllowBreak, bool DryRun,
147
                                                 bool Strict);
148
149
  /// Returns the \c BreakableToken starting at \p Current, or nullptr
150
  /// if the current token cannot be broken.
151
  std::unique_ptr<BreakableToken>
152
  createBreakableToken(const FormatToken &Current, LineState &State,
153
                       bool AllowBreak);
154
155
  /// Appends the next token to \p State and updates information
156
  /// necessary for indentation.
157
  ///
158
  /// Puts the token on the current line.
159
  ///
160
  /// If \p DryRun is \c false, also creates and stores the required
161
  /// \c Replacement.
162
  void addTokenOnCurrentLine(LineState &State, bool DryRun,
163
                             unsigned ExtraSpaces);
164
165
  /// Appends the next token to \p State and updates information
166
  /// necessary for indentation.
167
  ///
168
  /// Adds a line break and necessary indentation.
169
  ///
170
  /// If \p DryRun is \c false, also creates and stores the required
171
  /// \c Replacement.
172
  unsigned addTokenOnNewLine(LineState &State, bool DryRun);
173
174
  /// Calculate the new column for a line wrap before the next token.
175
  unsigned getNewLineColumn(const LineState &State);
176
177
  /// Adds a multiline token to the \p State.
178
  ///
179
  /// \returns Extra penalty for the first line of the literal: last line is
180
  /// handled in \c addNextStateToQueue, and the penalty for other lines doesn't
181
  /// matter, as we don't change them.
182
  unsigned addMultilineToken(const FormatToken &Current, LineState &State);
183
184
  /// Returns \c true if the next token starts a multiline string
185
  /// literal.
186
  ///
187
  /// This includes implicitly concatenated strings, strings that will be broken
188
  /// by clang-format and string literals with escaped newlines.
189
  bool nextIsMultilineString(const LineState &State);
190
191
  FormatStyle Style;
192
  const AdditionalKeywords &Keywords;
193
  const SourceManager &SourceMgr;
194
  WhitespaceManager &Whitespaces;
195
  encoding::Encoding Encoding;
196
  bool BinPackInconclusiveFunctions;
197
  llvm::Regex CommentPragmasRegex;
198
  const RawStringFormatStyleManager RawStringFormats;
199
};
200
201
struct ParenState {
202
  ParenState(const FormatToken *Tok, unsigned Indent, unsigned LastSpace,
203
             bool AvoidBinPacking, bool NoLineBreak)
204
      : Tok(Tok), Indent(Indent), LastSpace(LastSpace),
205
        NestedBlockIndent(Indent), IsAligned(false),
206
        BreakBeforeClosingBrace(false), BreakBeforeClosingParen(false),
207
        AvoidBinPacking(AvoidBinPacking), BreakBeforeParameter(false),
208
        NoLineBreak(NoLineBreak), NoLineBreakInOperand(false),
209
        LastOperatorWrapped(true), ContainsLineBreak(false),
210
        ContainsUnwrappedBuilder(false), AlignColons(true),
211
        ObjCSelectorNameFound(false), HasMultipleNestedBlocks(false),
212
        NestedBlockInlined(false), IsInsideObjCArrayLiteral(false),
213
        IsCSharpGenericTypeConstraint(false), IsChainedConditional(false),
214
299k
        IsWrappedConditional(false), UnindentOperator(false) {}
215
216
  /// \brief The token opening this parenthesis level, or nullptr if this level
217
  /// is opened by fake parenthesis.
218
  ///
219
  /// Not considered for memoization as it will always have the same value at
220
  /// the same token.
221
  const FormatToken *Tok;
222
223
  /// The position to which a specific parenthesis level needs to be
224
  /// indented.
225
  unsigned Indent;
226
227
  /// The position of the last space on each level.
228
  ///
229
  /// Used e.g. to break like:
230
  /// functionCall(Parameter, otherCall(
231
  ///                             OtherParameter));
232
  unsigned LastSpace;
233
234
  /// If a block relative to this parenthesis level gets wrapped, indent
235
  /// it this much.
236
  unsigned NestedBlockIndent;
237
238
  /// The position the first "<<" operator encountered on each level.
239
  ///
240
  /// Used to align "<<" operators. 0 if no such operator has been encountered
241
  /// on a level.
242
  unsigned FirstLessLess = 0;
243
244
  /// The column of a \c ? in a conditional expression;
245
  unsigned QuestionColumn = 0;
246
247
  /// The position of the colon in an ObjC method declaration/call.
248
  unsigned ColonPos = 0;
249
250
  /// The start of the most recent function in a builder-type call.
251
  unsigned StartOfFunctionCall = 0;
252
253
  /// Contains the start of array subscript expressions, so that they
254
  /// can be aligned.
255
  unsigned StartOfArraySubscripts = 0;
256
257
  /// If a nested name specifier was broken over multiple lines, this
258
  /// contains the start column of the second line. Otherwise 0.
259
  unsigned NestedNameSpecifierContinuation = 0;
260
261
  /// If a call expression was broken over multiple lines, this
262
  /// contains the start column of the second line. Otherwise 0.
263
  unsigned CallContinuation = 0;
264
265
  /// The column of the first variable name in a variable declaration.
266
  ///
267
  /// Used to align further variables if necessary.
268
  unsigned VariablePos = 0;
269
270
  /// Whether this block's indentation is used for alignment.
271
  bool IsAligned : 1;
272
273
  /// Whether a newline needs to be inserted before the block's closing
274
  /// brace.
275
  ///
276
  /// We only want to insert a newline before the closing brace if there also
277
  /// was a newline after the beginning left brace.
278
  bool BreakBeforeClosingBrace : 1;
279
280
  /// Whether a newline needs to be inserted before the block's closing
281
  /// paren.
282
  ///
283
  /// We only want to insert a newline before the closing paren if there also
284
  /// was a newline after the beginning left paren.
285
  bool BreakBeforeClosingParen : 1;
286
287
  /// Avoid bin packing, i.e. multiple parameters/elements on multiple
288
  /// lines, in this context.
289
  bool AvoidBinPacking : 1;
290
291
  /// Break after the next comma (or all the commas in this context if
292
  /// \c AvoidBinPacking is \c true).
293
  bool BreakBeforeParameter : 1;
294
295
  /// Line breaking in this context would break a formatting rule.
296
  bool NoLineBreak : 1;
297
298
  /// Same as \c NoLineBreak, but is restricted until the end of the
299
  /// operand (including the next ",").
300
  bool NoLineBreakInOperand : 1;
301
302
  /// True if the last binary operator on this level was wrapped to the
303
  /// next line.
304
  bool LastOperatorWrapped : 1;
305
306
  /// \c true if this \c ParenState already contains a line-break.
307
  ///
308
  /// The first line break in a certain \c ParenState causes extra penalty so
309
  /// that clang-format prefers similar breaks, i.e. breaks in the same
310
  /// parenthesis.
311
  bool ContainsLineBreak : 1;
312
313
  /// \c true if this \c ParenState contains multiple segments of a
314
  /// builder-type call on one line.
315
  bool ContainsUnwrappedBuilder : 1;
316
317
  /// \c true if the colons of the curren ObjC method expression should
318
  /// be aligned.
319
  ///
320
  /// Not considered for memoization as it will always have the same value at
321
  /// the same token.
322
  bool AlignColons : 1;
323
324
  /// \c true if at least one selector name was found in the current
325
  /// ObjC method expression.
326
  ///
327
  /// Not considered for memoization as it will always have the same value at
328
  /// the same token.
329
  bool ObjCSelectorNameFound : 1;
330
331
  /// \c true if there are multiple nested blocks inside these parens.
332
  ///
333
  /// Not considered for memoization as it will always have the same value at
334
  /// the same token.
335
  bool HasMultipleNestedBlocks : 1;
336
337
  /// The start of a nested block (e.g. lambda introducer in C++ or
338
  /// "function" in JavaScript) is not wrapped to a new line.
339
  bool NestedBlockInlined : 1;
340
341
  /// \c true if the current \c ParenState represents an Objective-C
342
  /// array literal.
343
  bool IsInsideObjCArrayLiteral : 1;
344
345
  bool IsCSharpGenericTypeConstraint : 1;
346
347
  /// \brief true if the current \c ParenState represents the false branch of
348
  /// a chained conditional expression (e.g. else-if)
349
  bool IsChainedConditional : 1;
350
351
  /// \brief true if there conditionnal was wrapped on the first operator (the
352
  /// question mark)
353
  bool IsWrappedConditional : 1;
354
355
  /// \brief Indicates the indent should be reduced by the length of the
356
  /// operator.
357
  bool UnindentOperator : 1;
358
359
32.8M
  bool operator<(const ParenState &Other) const {
360
32.8M
    if (Indent != Other.Indent)
361
2.92M
      return Indent < Other.Indent;
362
29.9M
    if (LastSpace != Other.LastSpace)
363
867k
      return LastSpace < Other.LastSpace;
364
29.0M
    if (NestedBlockIndent != Other.NestedBlockIndent)
365
939
      return NestedBlockIndent < Other.NestedBlockIndent;
366
29.0M
    if (FirstLessLess != Other.FirstLessLess)
367
0
      return FirstLessLess < Other.FirstLessLess;
368
29.0M
    if (IsAligned != Other.IsAligned)
369
63
      return IsAligned;
370
29.0M
    if (BreakBeforeClosingBrace != Other.BreakBeforeClosingBrace)
371
0
      return BreakBeforeClosingBrace;
372
29.0M
    if (BreakBeforeClosingParen != Other.BreakBeforeClosingParen)
373
0
      return BreakBeforeClosingParen;
374
29.0M
    if (QuestionColumn != Other.QuestionColumn)
375
1.65k
      return QuestionColumn < Other.QuestionColumn;
376
29.0M
    if (AvoidBinPacking != Other.AvoidBinPacking)
377
0
      return AvoidBinPacking;
378
29.0M
    if (BreakBeforeParameter != Other.BreakBeforeParameter)
379
2.21k
      return BreakBeforeParameter;
380
29.0M
    if (NoLineBreak != Other.NoLineBreak)
381
66.3k
      return NoLineBreak;
382
28.9M
    if (LastOperatorWrapped != Other.LastOperatorWrapped)
383
3
      return LastOperatorWrapped;
384
28.9M
    if (ColonPos != Other.ColonPos)
385
6
      return ColonPos < Other.ColonPos;
386
28.9M
    if (StartOfFunctionCall != Other.StartOfFunctionCall)
387
36
      return StartOfFunctionCall < Other.StartOfFunctionCall;
388
28.9M
    if (StartOfArraySubscripts != Other.StartOfArraySubscripts)
389
0
      return StartOfArraySubscripts < Other.StartOfArraySubscripts;
390
28.9M
    if (CallContinuation != Other.CallContinuation)
391
24
      return CallContinuation < Other.CallContinuation;
392
28.9M
    if (VariablePos != Other.VariablePos)
393
98.0k
      return VariablePos < Other.VariablePos;
394
28.8M
    if (ContainsLineBreak != Other.ContainsLineBreak)
395
636
      return ContainsLineBreak;
396
28.8M
    if (ContainsUnwrappedBuilder != Other.ContainsUnwrappedBuilder)
397
0
      return ContainsUnwrappedBuilder;
398
28.8M
    if (NestedBlockInlined != Other.NestedBlockInlined)
399
1.55k
      return NestedBlockInlined;
400
28.8M
    if (IsCSharpGenericTypeConstraint != Other.IsCSharpGenericTypeConstraint)
401
0
      return IsCSharpGenericTypeConstraint;
402
28.8M
    if (IsChainedConditional != Other.IsChainedConditional)
403
0
      return IsChainedConditional;
404
28.8M
    if (IsWrappedConditional != Other.IsWrappedConditional)
405
0
      return IsWrappedConditional;
406
28.8M
    if (UnindentOperator != Other.UnindentOperator)
407
0
      return UnindentOperator;
408
28.8M
    return false;
409
28.8M
  }
410
};
411
412
/// The current state when indenting a unwrapped line.
413
///
414
/// As the indenting tries different combinations this is copied by value.
415
struct LineState {
416
  /// The number of used columns in the current line.
417
  unsigned Column;
418
419
  /// The token that needs to be next formatted.
420
  FormatToken *NextToken;
421
422
  /// \c true if \p NextToken should not continue this line.
423
  bool NoContinuation;
424
425
  /// The \c NestingLevel at the start of this line.
426
  unsigned StartOfLineLevel;
427
428
  /// The lowest \c NestingLevel on the current line.
429
  unsigned LowestLevelOnLine;
430
431
  /// The start column of the string literal, if we're in a string
432
  /// literal sequence, 0 otherwise.
433
  unsigned StartOfStringLiteral;
434
435
  /// A stack keeping track of properties applying to parenthesis
436
  /// levels.
437
  SmallVector<ParenState> Stack;
438
439
  /// Ignore the stack of \c ParenStates for state comparison.
440
  ///
441
  /// In long and deeply nested unwrapped lines, the current algorithm can
442
  /// be insufficient for finding the best formatting with a reasonable amount
443
  /// of time and memory. Setting this flag will effectively lead to the
444
  /// algorithm not analyzing some combinations. However, these combinations
445
  /// rarely contain the optimal solution: In short, accepting a higher
446
  /// penalty early would need to lead to different values in the \c
447
  /// ParenState stack (in an otherwise identical state) and these different
448
  /// values would need to lead to a significant amount of avoided penalty
449
  /// later.
450
  ///
451
  /// FIXME: Come up with a better algorithm instead.
452
  bool IgnoreStackForComparison;
453
454
  /// The indent of the first token.
455
  unsigned FirstIndent;
456
457
  /// The line that is being formatted.
458
  ///
459
  /// Does not need to be considered for memoization because it doesn't change.
460
  const AnnotatedLine *Line;
461
462
  /// Comparison operator to be able to used \c LineState in \c map.
463
14.9M
  bool operator<(const LineState &Other) const {
464
14.9M
    if (NextToken != Other.NextToken)
465
6.25M
      return NextToken < Other.NextToken;
466
8.68M
    if (Column != Other.Column)
467
3.98M
      return Column < Other.Column;
468
4.70M
    if (NoContinuation != Other.NoContinuation)
469
0
      return NoContinuation;
470
4.70M
    if (StartOfLineLevel != Other.StartOfLineLevel)
471
1.53M
      return StartOfLineLevel < Other.StartOfLineLevel;
472
3.17M
    if (LowestLevelOnLine != Other.LowestLevelOnLine)
473
4
      return LowestLevelOnLine < Other.LowestLevelOnLine;
474
3.17M
    if (StartOfStringLiteral != Other.StartOfStringLiteral)
475
157
      return StartOfStringLiteral < Other.StartOfStringLiteral;
476
3.17M
    if (IgnoreStackForComparison || 
Other.IgnoreStackForComparison2.98M
)
477
228k
      return false;
478
2.94M
    return Stack < Other.Stack;
479
3.17M
  }
480
};
481
482
} // end namespace format
483
} // end namespace clang
484
485
#endif