clang  15.0.0git
ContinuationIndenter.h
Go to the documentation of this file.
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 
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 
47  getEnclosingFunctionStyle(StringRef EnclosingFunction) const;
48 };
49 
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)
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.
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.
256 
257  /// If a nested name specifier was broken over multiple lines, this
258  /// contains the start column of the second line. Otherwise 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.
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.
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).
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 ",").
301 
302  /// True if the last binary operator on this level was wrapped to the
303  /// next line.
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.
312 
313  /// \c true if this \c ParenState contains multiple segments of a
314  /// builder-type call on one line.
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.
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.
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.
340 
341  /// \c true if the current \c ParenState represents an Objective-C
342  /// array literal.
344 
346 
347  /// \brief true if the current \c ParenState represents the false branch of
348  /// a chained conditional expression (e.g. else-if)
350 
351  /// \brief true if there conditionnal was wrapped on the first operator (the
352  /// question mark)
354 
355  /// \brief Indicates the indent should be reduced by the length of the
356  /// operator.
358 
359  bool operator<(const ParenState &Other) const {
360  if (Indent != Other.Indent)
361  return Indent < Other.Indent;
362  if (LastSpace != Other.LastSpace)
363  return LastSpace < Other.LastSpace;
365  return NestedBlockIndent < Other.NestedBlockIndent;
366  if (FirstLessLess != Other.FirstLessLess)
367  return FirstLessLess < Other.FirstLessLess;
368  if (IsAligned != Other.IsAligned)
369  return IsAligned;
374  if (QuestionColumn != Other.QuestionColumn)
375  return QuestionColumn < Other.QuestionColumn;
376  if (AvoidBinPacking != Other.AvoidBinPacking)
377  return AvoidBinPacking;
379  return BreakBeforeParameter;
380  if (NoLineBreak != Other.NoLineBreak)
381  return NoLineBreak;
383  return LastOperatorWrapped;
384  if (ColonPos != Other.ColonPos)
385  return ColonPos < Other.ColonPos;
390  if (CallContinuation != Other.CallContinuation)
391  return CallContinuation < Other.CallContinuation;
392  if (VariablePos != Other.VariablePos)
393  return VariablePos < Other.VariablePos;
395  return ContainsLineBreak;
399  return NestedBlockInlined;
403  return IsChainedConditional;
405  return IsWrappedConditional;
406  if (UnindentOperator != Other.UnindentOperator)
407  return UnindentOperator;
408  return false;
409  }
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.
421 
422  /// \c true if \p NextToken should not continue this line.
424 
425  /// The \c NestingLevel at the start of this line.
427 
428  /// The lowest \c NestingLevel on the current line.
430 
431  /// The start column of the string literal, if we're in a string
432  /// literal sequence, 0 otherwise.
434 
435  /// A stack keeping track of properties applying to parenthesis
436  /// levels.
437  std::vector<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.
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.
461 
462  /// Comparison operator to be able to used \c LineState in \c map.
463  bool operator<(const LineState &Other) const {
464  if (NextToken != Other.NextToken)
465  return NextToken < Other.NextToken;
466  if (Column != Other.Column)
467  return Column < Other.Column;
468  if (NoContinuation != Other.NoContinuation)
469  return NoContinuation;
470  if (StartOfLineLevel != Other.StartOfLineLevel)
471  return StartOfLineLevel < Other.StartOfLineLevel;
473  return LowestLevelOnLine < Other.LowestLevelOnLine;
477  return false;
478  return Stack < Other.Stack;
479  }
480 };
481 
482 } // end namespace format
483 } // end namespace clang
484 
485 #endif
clang::format::ParenState::Indent
unsigned Indent
The position to which a specific parenthesis level needs to be indented.
Definition: ContinuationIndenter.h:225
clang::format::ParenState::UnindentOperator
bool UnindentOperator
Indicates the indent should be reduced by the length of the operator.
Definition: ContinuationIndenter.h:357
clang::format::LineState::StartOfStringLiteral
unsigned StartOfStringLiteral
The start column of the string literal, if we're in a string literal sequence, 0 otherwise.
Definition: ContinuationIndenter.h:433
clang::format::LineState::Column
unsigned Column
The number of used columns in the current line.
Definition: ContinuationIndenter.h:417
clang::format::LineState::NoContinuation
bool NoContinuation
true if NextToken should not continue this line.
Definition: ContinuationIndenter.h:423
clang::format::ParenState::Tok
const FormatToken * Tok
The token opening this parenthesis level, or nullptr if this level is opened by fake parenthesis.
Definition: ContinuationIndenter.h:221
clang::format::ParenState::NoLineBreak
bool NoLineBreak
Line breaking in this context would break a formatting rule.
Definition: ContinuationIndenter.h:296
clang::format::ParenState::LastSpace
unsigned LastSpace
The position of the last space on each level.
Definition: ContinuationIndenter.h:232
clang::format::ContinuationIndenter::ContinuationIndenter
ContinuationIndenter(const FormatStyle &Style, const AdditionalKeywords &Keywords, const SourceManager &SourceMgr, WhitespaceManager &Whitespaces, encoding::Encoding Encoding, bool BinPackInconclusiveFunctions)
Constructs a ContinuationIndenter to format Line starting in column FirstIndent.
Definition: ContinuationIndenter.cpp:223
clang::format::ParenState::FirstLessLess
unsigned FirstLessLess
The position the first "<<" operator encountered on each level.
Definition: ContinuationIndenter.h:242
clang::format::ParenState::ContainsUnwrappedBuilder
bool ContainsUnwrappedBuilder
true if this ParenState contains multiple segments of a builder-type call on one line.
Definition: ContinuationIndenter.h:315
clang::format::FormatStyle
The FormatStyle is used to configure the formatting to follow specific guidelines.
Definition: Format.h:54
clang::format::FormatToken
A wrapper around a Token storing information about the whitespace characters preceding it.
Definition: FormatToken.h:227
clang::format::ParenState::CallContinuation
unsigned CallContinuation
If a call expression was broken over multiple lines, this contains the start column of the second lin...
Definition: ContinuationIndenter.h:263
clang::format::AdditionalKeywords
Encapsulates keywords that are context sensitive or for languages not properly supported by Clang's l...
Definition: FormatToken.h:885
llvm::Optional
Definition: LLVM.h:40
clang::format::ParenState::HasMultipleNestedBlocks
bool HasMultipleNestedBlocks
true if there are multiple nested blocks inside these parens.
Definition: ContinuationIndenter.h:335
clang::format::ParenState::NestedNameSpecifierContinuation
unsigned NestedNameSpecifierContinuation
If a nested name specifier was broken over multiple lines, this contains the start column of the seco...
Definition: ContinuationIndenter.h:259
clang::format::ParenState::NestedBlockInlined
bool NestedBlockInlined
The start of a nested block (e.g.
Definition: ContinuationIndenter.h:339
Format.h
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:627
clang::format::ParenState::BreakBeforeClosingParen
bool BreakBeforeClosingParen
Whether a newline needs to be inserted before the block's closing paren.
Definition: ContinuationIndenter.h:285
Encoding.h
clang::format::ParenState::BreakBeforeParameter
bool BreakBeforeParameter
Break after the next comma (or all the commas in this context if AvoidBinPacking is true).
Definition: ContinuationIndenter.h:293
clang::format::ParenState::ObjCSelectorNameFound
bool ObjCSelectorNameFound
true if at least one selector name was found in the current ObjC method expression.
Definition: ContinuationIndenter.h:329
clang::format::LineState
The current state when indenting a unwrapped line.
Definition: ContinuationIndenter.h:415
clang::format::ParenState::AvoidBinPacking
bool AvoidBinPacking
Avoid bin packing, i.e.
Definition: ContinuationIndenter.h:289
clang::format::ParenState::StartOfArraySubscripts
unsigned StartOfArraySubscripts
Contains the start of array subscript expressions, so that they can be aligned.
Definition: ContinuationIndenter.h:255
clang::format::ParenState::VariablePos
unsigned VariablePos
The column of the first variable name in a variable declaration.
Definition: ContinuationIndenter.h:268
clang::format::encoding::Encoding
Encoding
Definition: Encoding.h:27
clang::format::WhitespaceManager
Manages the whitespaces around tokens and their replacements.
Definition: WhitespaceManager.h:40
clang::format::LineState::IgnoreStackForComparison
bool IgnoreStackForComparison
Ignore the stack of ParenStates for state comparison.
Definition: ContinuationIndenter.h:452
clang::format::AnnotatedLine
Definition: TokenAnnotator.h:36
clang::format::ContinuationIndenter::getInitialState
LineState getInitialState(unsigned FirstIndent, unsigned FirstStartColumn, const AnnotatedLine *Line, bool DryRun)
Get the initial state, i.e.
Definition: ContinuationIndenter.cpp:234
clang::format::RawStringFormatStyleManager::RawStringFormatStyleManager
RawStringFormatStyleManager(const FormatStyle &CodeStyle)
Definition: ContinuationIndenter.cpp:184
clang::format::ContinuationIndenter::getColumnLimit
unsigned getColumnLimit(const LineState &State) const
Get the column limit for this line.
Definition: ContinuationIndenter.cpp:2443
clang::format::ParenState
Definition: ContinuationIndenter.h:201
clang::format::ParenState::ContainsLineBreak
bool ContainsLineBreak
true if this ParenState already contains a line-break.
Definition: ContinuationIndenter.h:311
Line
const AnnotatedLine * Line
Definition: UsingDeclarationsSorter.cpp:68
clang::format::LineState::Line
const AnnotatedLine * Line
The line that is being formatted.
Definition: ContinuationIndenter.h:460
clang::format::ParenState::BreakBeforeClosingBrace
bool BreakBeforeClosingBrace
Whether a newline needs to be inserted before the block's closing brace.
Definition: ContinuationIndenter.h:278
clang::format::RawStringFormatStyleManager::getDelimiterStyle
llvm::Optional< FormatStyle > getDelimiterStyle(StringRef Delimiter) const
Definition: ContinuationIndenter.cpp:207
false
#define false
Definition: stdbool.h:22
clang::format::ParenState::ColonPos
unsigned ColonPos
The position of the colon in an ObjC method declaration/call.
Definition: ContinuationIndenter.h:248
clang::format::RawStringFormatStyleManager::getEnclosingFunctionStyle
llvm::Optional< FormatStyle > getEnclosingFunctionStyle(StringRef EnclosingFunction) const
Definition: ContinuationIndenter.cpp:215
clang::format::RawStringFormatStyleManager::EnclosingFunctionStyle
llvm::StringMap< FormatStyle > EnclosingFunctionStyle
Definition: ContinuationIndenter.h:40
clang::format::LineState::NextToken
FormatToken * NextToken
The token that needs to be next formatted.
Definition: ContinuationIndenter.h:420
clang::format::LineState::operator<
bool operator<(const LineState &Other) const
Comparison operator to be able to used LineState in map.
Definition: ContinuationIndenter.h:463
State
LineState State
Definition: UnwrappedLineFormatter.cpp:1089
clang::format::ParenState::IsChainedConditional
bool IsChainedConditional
true if the current ParenState represents the false branch of a chained conditional expression (e....
Definition: ContinuationIndenter.h:349
clang::format::ParenState::StartOfFunctionCall
unsigned StartOfFunctionCall
The start of the most recent function in a builder-type call.
Definition: ContinuationIndenter.h:251
clang::format::ContinuationIndenter
Definition: ContinuationIndenter.h:50
clang::format::ContinuationIndenter::canBreak
bool canBreak(const LineState &State)
Returns true, if a line break after State is allowed.
Definition: ContinuationIndenter.cpp:276
clang::format::LineState::Stack
std::vector< ParenState > Stack
A stack keeping track of properties applying to parenthesis levels.
Definition: ContinuationIndenter.h:437
clang::format::ParenState::QuestionColumn
unsigned QuestionColumn
The column of a ? in a conditional expression;.
Definition: ContinuationIndenter.h:245
clang::format::LineState::StartOfLineLevel
unsigned StartOfLineLevel
The NestingLevel at the start of this line.
Definition: ContinuationIndenter.h:426
clang::format::ParenState::IsInsideObjCArrayLiteral
bool IsInsideObjCArrayLiteral
true if the current ParenState represents an Objective-C array literal.
Definition: ContinuationIndenter.h:343
clang
Definition: CalledOnceCheck.h:17
clang::format::RawStringFormatStyleManager::DelimiterStyle
llvm::StringMap< FormatStyle > DelimiterStyle
Definition: ContinuationIndenter.h:39
clang::format::ContinuationIndenter::addTokenToState
unsigned addTokenToState(LineState &State, bool Newline, bool DryRun, unsigned ExtraSpaces=0)
Appends the next token to State and updates information necessary for indentation.
Definition: ContinuationIndenter.cpp:562
clang::format::ParenState::operator<
bool operator<(const ParenState &Other) const
Definition: ContinuationIndenter.h:359
clang::format::ParenState::IsCSharpGenericTypeConstraint
bool IsCSharpGenericTypeConstraint
Definition: ContinuationIndenter.h:345
clang::format::ParenState::NoLineBreakInOperand
bool NoLineBreakInOperand
Same as NoLineBreak, but is restricted until the end of the operand (including the next ",...
Definition: ContinuationIndenter.h:300
clang::format::ParenState::IsAligned
bool IsAligned
Whether this block's indentation is used for alignment.
Definition: ContinuationIndenter.h:271
clang::format::ContinuationIndenter::mustBreak
bool mustBreak(const LineState &State)
Returns true, if a line break after State is mandatory.
Definition: ContinuationIndenter.cpp:329
clang::format::ParenState::ParenState
ParenState(const FormatToken *Tok, unsigned Indent, unsigned LastSpace, bool AvoidBinPacking, bool NoLineBreak)
Definition: ContinuationIndenter.h:202
clang::format::ParenState::LastOperatorWrapped
bool LastOperatorWrapped
True if the last binary operator on this level was wrapped to the next line.
Definition: ContinuationIndenter.h:304
FormatToken.h
clang::format::LineState::LowestLevelOnLine
unsigned LowestLevelOnLine
The lowest NestingLevel on the current line.
Definition: ContinuationIndenter.h:429
true
#define true
Definition: stdbool.h:21
clang::format::LineState::FirstIndent
unsigned FirstIndent
The indent of the first token.
Definition: ContinuationIndenter.h:455
clang::format::ParenState::IsWrappedConditional
bool IsWrappedConditional
true if there conditionnal was wrapped on the first operator (the question mark)
Definition: ContinuationIndenter.h:353
clang::format::ParenState::AlignColons
bool AlignColons
true if the colons of the curren ObjC method expression should be aligned.
Definition: ContinuationIndenter.h:322
clang::format::RawStringFormatStyleManager
Definition: ContinuationIndenter.h:38
clang::format::ParenState::NestedBlockIndent
unsigned NestedBlockIndent
If a block relative to this parenthesis level gets wrapped, indent it this much.
Definition: ContinuationIndenter.h:236