14#ifndef LLVM_CLANG_FORMAT_FORMAT_H
15#define LLVM_CLANG_FORMAT_FORMAT_H
20#include "llvm/ADT/ArrayRef.h"
21#include "llvm/Support/Regex.h"
22#include "llvm/Support/SourceMgr.h"
24#include <system_error>
47 const char *
name()
const noexcept override;
48 std::string
message(
int EV)
const override;
59 bool InheritsParentConfig;
63 int AccessModifierOffset;
66 enum BracketAlignmentStyle : int8_t {
107 BracketAlignmentStyle AlignAfterOpenBracket;
110 enum ArrayInitializerAlignmentStyle : int8_t {
143 ArrayInitializerAlignmentStyle AlignArrayOfStructures;
165 struct AlignConsecutiveStyle {
203 bool AcrossEmptyLines;
242 bool AlignFunctionDeclarations;
258 bool AlignFunctionPointers;
278 bool operator==(
const AlignConsecutiveStyle &R)
const {
279 return Enabled == R.Enabled && AcrossEmptyLines == R.AcrossEmptyLines &&
280 AcrossComments == R.AcrossComments &&
281 AlignCompound == R.AlignCompound &&
282 AlignFunctionDeclarations == R.AlignFunctionDeclarations &&
283 AlignFunctionPointers == R.AlignFunctionPointers &&
284 PadOperators == R.PadOperators;
286 bool operator!=(
const AlignConsecutiveStyle &R)
const {
287 return !(*
this == R);
302 AlignConsecutiveStyle AlignConsecutiveMacros;
312 AlignConsecutiveStyle AlignConsecutiveAssignments;
323 AlignConsecutiveStyle AlignConsecutiveBitFields;
334 AlignConsecutiveStyle AlignConsecutiveDeclarations;
338 struct ShortCaseStatementsAlignmentStyle {
374 bool AcrossEmptyLines;
410 bool AlignCaseArrows;
428 bool AlignCaseColons;
429 bool operator==(
const ShortCaseStatementsAlignmentStyle &R)
const {
430 return Enabled == R.Enabled && AcrossEmptyLines == R.AcrossEmptyLines &&
431 AcrossComments == R.AcrossComments &&
432 AlignCaseArrows == R.AlignCaseArrows &&
433 AlignCaseColons == R.AlignCaseColons;
450 ShortCaseStatementsAlignmentStyle AlignConsecutiveShortCaseStatements;
465 AlignConsecutiveStyle AlignConsecutiveTableGenBreakingDAGArgColons;
475 AlignConsecutiveStyle AlignConsecutiveTableGenCondOperatorColons;
485 AlignConsecutiveStyle AlignConsecutiveTableGenDefinitionColons;
488 enum EscapedNewlineAlignmentStyle : int8_t {
513 ENAS_LeftWithLastLine,
526 EscapedNewlineAlignmentStyle AlignEscapedNewlines;
529 enum OperandAlignmentStyle : int8_t {
559 OAS_AlignAfterOperator,
565 OperandAlignmentStyle AlignOperands;
568 enum TrailingCommentsAlignmentKinds : int8_t {
599 struct TrailingCommentsAlignmentStyle {
601 TrailingCommentsAlignmentKinds
Kind;
624 unsigned OverEmptyLines;
626 bool operator==(
const TrailingCommentsAlignmentStyle &R)
const {
627 return Kind == R.Kind && OverEmptyLines == R.OverEmptyLines;
629 bool operator!=(
const TrailingCommentsAlignmentStyle &R)
const {
630 return !(*
this == R);
652 TrailingCommentsAlignmentStyle AlignTrailingComments;
669 bool AllowAllArgumentsOnNextLine;
692 bool AllowAllParametersOfDeclarationOnNextLine;
695 enum BreakBeforeNoexceptSpecifierStyle : int8_t {
733 BreakBeforeNoexceptSpecifierStyle AllowBreakBeforeNoexceptSpecifier;
737 enum ShortBlockStyle : int8_t {
766 ShortBlockStyle AllowShortBlocksOnASingleLine;
779 bool AllowShortCaseExpressionOnASingleLine;
793 bool AllowShortCaseLabelsOnASingleLine;
812 bool AllowShortCompoundRequirementOnASingleLine;
826 bool AllowShortEnumsOnASingleLine;
830 enum ShortFunctionStyle : int8_t {
879 ShortFunctionStyle AllowShortFunctionsOnASingleLine;
882 enum ShortIfStyle : int8_t {
950 ShortIfStyle AllowShortIfStatementsOnASingleLine;
954 enum ShortLambdaStyle : int8_t {
984 ShortLambdaStyle AllowShortLambdasOnASingleLine;
989 bool AllowShortLoopsOnASingleLine;
993 bool AllowShortNamespacesOnASingleLine;
997 enum DefinitionReturnTypeBreakingStyle : int8_t {
1009 enum ReturnTypeBreakingStyle : int8_t {
1034 RTBS_ExceptShortType,
1084 RTBS_AllDefinitions,
1098 RTBS_TopLevelDefinitions,
1104 DefinitionReturnTypeBreakingStyle AlwaysBreakAfterDefinitionReturnType;
1124 bool AlwaysBreakBeforeMultilineStrings;
1127 enum BreakTemplateDeclarationsStyle : int8_t {
1194 std::vector<std::string> AttributeMacros;
1213 bool BinPackArguments;
1229 bool BinPackLongBracedList;
1232 enum BinPackParametersStyle : int8_t {
1255 BPPS_AlwaysOnePerLine,
1260 BinPackParametersStyle BinPackParameters;
1263 enum BitFieldColonSpacingStyle : int8_t {
1289 BitFieldColonSpacingStyle BitFieldColonSpacing;
1322 int BracedInitializerIndentWidth;
1325 enum BraceWrappingAfterControlStatementStyle : int8_t {
1365 struct BraceWrappingFlags {
1381 bool AfterCaseLabel;
1394 BraceWrappingAfterControlStatementStyle AfterControlStatement;
1438 bool AfterNamespace;
1444 bool AfterObjCDeclaration;
1486 bool AfterExternBlock;
1533 bool BeforeLambdaBody;
1563 bool SplitEmptyFunction;
1575 bool SplitEmptyRecord;
1587 bool SplitEmptyNamespace;
1603 BraceWrappingFlags BraceWrapping;
1616 bool BreakAdjacentStringLiterals;
1619 enum AttributeBreakingStyle : int8_t {
1703 AttributeBreakingStyle BreakAfterAttributes;
1707 ReturnTypeBreakingStyle BreakAfterReturnType;
1730 enum BinPackStyle : int8_t {
1740 enum BinaryOperatorStyle : int8_t {
1781 BinaryOperatorStyle BreakBeforeBinaryOperators;
1784 enum BraceBreakingStyle : int8_t {
2216 BraceBreakingStyle BreakBeforeBraces;
2219 enum BreakBeforeConceptDeclarationsStyle : int8_t {
2240 BreakBeforeConceptDeclarationsStyle BreakBeforeConceptDeclarations;
2243 enum BreakBeforeInlineASMColonStyle : int8_t {
2257 BBIAS_OnlyMultiline,
2269 BreakBeforeInlineASMColonStyle BreakBeforeInlineASMColon;
2296 bool BreakBeforeTemplateCloser;
2311 bool BreakBeforeTernaryOperators;
2314 enum BreakBinaryOperationsStyle : int8_t {
2341 BBO_RespectPrecedence
2346 BreakBinaryOperationsStyle BreakBinaryOperations;
2349 enum BreakConstructorInitializersStyle : int8_t {
2376 BreakConstructorInitializersStyle BreakConstructorInitializers;
2390 bool BreakFunctionDefinitionParameters;
2400 bool BreakAfterJavaFieldAnnotations;
2443 bool BreakStringLiterals;
2451 unsigned ColumnLimit;
2461 std::string CommentPragmas;
2464 enum BreakInheritanceListStyle : int8_t {
2501 BreakInheritanceListStyle BreakInheritanceList;
2505 BreakTemplateDeclarationsStyle BreakTemplateDeclarations;
2529 bool CompactNamespaces;
2539 unsigned ConstructorInitializerIndentWidth;
2550 unsigned ContinuationIndentWidth;
2574 bool Cpp11BracedListStyle;
2587 bool DerivePointerAlignment;
2596 enum EmptyLineAfterAccessModifierStyle : int8_t {
2642 EmptyLineAfterAccessModifierStyle EmptyLineAfterAccessModifier;
2645 enum EmptyLineBeforeAccessModifierStyle : int8_t {
2680 ELBAMS_LogicalBlock,
2705 EmptyLineBeforeAccessModifierStyle EmptyLineBeforeAccessModifier;
2708 enum EnumTrailingCommaStyle : int8_t {
2738 EnumTrailingCommaStyle EnumTrailingComma;
2753 bool ExperimentalAutoDetectBinPacking;
2769 bool FixNamespaceComments;
2787 std::vector<std::string> ForEachMacros;
2789 tooling::IncludeStyle IncludeStyle;
2810 std::vector<std::string> IfMacros;
2837 bool IndentAccessModifiers;
2860 bool IndentCaseBlocks;
2879 bool IndentCaseLabels;
2892 bool IndentExportBlock;
2895 enum IndentExternBlockStyle : int8_t {
2913 IEBS_AfterExternBlock,
2932 IndentExternBlockStyle IndentExternBlock;
2949 bool IndentGotoLabels;
2952 enum PPDirectiveIndentStyle : int8_t {
2996 PPDirectiveIndentStyle IndentPPDirectives;
3019 bool IndentRequiresClause;
3033 unsigned IndentWidth;
3047 bool IndentWrappedFunctionNames;
3083 bool InsertNewlineAtEOF;
3086 enum TrailingCommaStyle : int8_t {
3113 TrailingCommaStyle InsertTrailingCommas;
3134 struct IntegerLiteralSeparatorStyle {
3150 int8_t BinaryMinDigits;
3165 int8_t DecimalMinDigits;
3181 int8_t HexMinDigits;
3182 bool operator==(
const IntegerLiteralSeparatorStyle &R)
const {
3183 return Binary == R.Binary && BinaryMinDigits == R.BinaryMinDigits &&
3184 Decimal == R.Decimal && DecimalMinDigits == R.DecimalMinDigits &&
3185 Hex == R.Hex && HexMinDigits == R.HexMinDigits;
3632 return !(*
this == R);
4481 return !(*
this == R);
4849 Other.AfterFunctionDeclarationName &&
5152 return !(*
this == R);
5438 return AccessModifierOffset == R.AccessModifierOffset &&
5439 AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
5440 AlignArrayOfStructures == R.AlignArrayOfStructures &&
5441 AlignConsecutiveAssignments == R.AlignConsecutiveAssignments &&
5442 AlignConsecutiveBitFields == R.AlignConsecutiveBitFields &&
5443 AlignConsecutiveDeclarations == R.AlignConsecutiveDeclarations &&
5444 AlignConsecutiveMacros == R.AlignConsecutiveMacros &&
5445 AlignConsecutiveShortCaseStatements ==
5446 R.AlignConsecutiveShortCaseStatements &&
5447 AlignConsecutiveTableGenBreakingDAGArgColons ==
5448 R.AlignConsecutiveTableGenBreakingDAGArgColons &&
5449 AlignConsecutiveTableGenCondOperatorColons ==
5450 R.AlignConsecutiveTableGenCondOperatorColons &&
5451 AlignConsecutiveTableGenDefinitionColons ==
5452 R.AlignConsecutiveTableGenDefinitionColons &&
5453 AlignEscapedNewlines == R.AlignEscapedNewlines &&
5454 AlignOperands == R.AlignOperands &&
5455 AlignTrailingComments == R.AlignTrailingComments &&
5456 AllowAllArgumentsOnNextLine == R.AllowAllArgumentsOnNextLine &&
5457 AllowAllParametersOfDeclarationOnNextLine ==
5458 R.AllowAllParametersOfDeclarationOnNextLine &&
5459 AllowBreakBeforeNoexceptSpecifier ==
5460 R.AllowBreakBeforeNoexceptSpecifier &&
5461 AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine &&
5462 AllowShortCaseExpressionOnASingleLine ==
5463 R.AllowShortCaseExpressionOnASingleLine &&
5464 AllowShortCaseLabelsOnASingleLine ==
5465 R.AllowShortCaseLabelsOnASingleLine &&
5466 AllowShortCompoundRequirementOnASingleLine ==
5467 R.AllowShortCompoundRequirementOnASingleLine &&
5468 AllowShortEnumsOnASingleLine == R.AllowShortEnumsOnASingleLine &&
5469 AllowShortFunctionsOnASingleLine ==
5470 R.AllowShortFunctionsOnASingleLine &&
5471 AllowShortIfStatementsOnASingleLine ==
5472 R.AllowShortIfStatementsOnASingleLine &&
5473 AllowShortLambdasOnASingleLine == R.AllowShortLambdasOnASingleLine &&
5474 AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine &&
5475 AllowShortNamespacesOnASingleLine ==
5476 R.AllowShortNamespacesOnASingleLine &&
5477 AlwaysBreakBeforeMultilineStrings ==
5478 R.AlwaysBreakBeforeMultilineStrings &&
5479 AttributeMacros == R.AttributeMacros &&
5480 BinPackArguments == R.BinPackArguments &&
5481 BinPackLongBracedList == R.BinPackLongBracedList &&
5482 BinPackParameters == R.BinPackParameters &&
5483 BitFieldColonSpacing == R.BitFieldColonSpacing &&
5484 BracedInitializerIndentWidth == R.BracedInitializerIndentWidth &&
5485 BreakAdjacentStringLiterals == R.BreakAdjacentStringLiterals &&
5486 BreakAfterAttributes == R.BreakAfterAttributes &&
5487 BreakAfterJavaFieldAnnotations == R.BreakAfterJavaFieldAnnotations &&
5488 BreakAfterReturnType == R.BreakAfterReturnType &&
5489 BreakArrays == R.BreakArrays &&
5490 BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators &&
5491 BreakBeforeBraces == R.BreakBeforeBraces &&
5492 BreakBeforeConceptDeclarations == R.BreakBeforeConceptDeclarations &&
5493 BreakBeforeInlineASMColon == R.BreakBeforeInlineASMColon &&
5494 BreakBeforeTemplateCloser == R.BreakBeforeTemplateCloser &&
5495 BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators &&
5496 BreakBinaryOperations == R.BreakBinaryOperations &&
5497 BreakConstructorInitializers == R.BreakConstructorInitializers &&
5498 BreakFunctionDefinitionParameters ==
5499 R.BreakFunctionDefinitionParameters &&
5500 BreakInheritanceList == R.BreakInheritanceList &&
5501 BreakStringLiterals == R.BreakStringLiterals &&
5502 BreakTemplateDeclarations == R.BreakTemplateDeclarations &&
5503 ColumnLimit == R.ColumnLimit && CommentPragmas == R.CommentPragmas &&
5504 CompactNamespaces == R.CompactNamespaces &&
5505 ConstructorInitializerIndentWidth ==
5506 R.ConstructorInitializerIndentWidth &&
5507 ContinuationIndentWidth == R.ContinuationIndentWidth &&
5508 Cpp11BracedListStyle == R.Cpp11BracedListStyle &&
5509 DerivePointerAlignment == R.DerivePointerAlignment &&
5510 DisableFormat == R.DisableFormat &&
5511 EmptyLineAfterAccessModifier == R.EmptyLineAfterAccessModifier &&
5512 EmptyLineBeforeAccessModifier == R.EmptyLineBeforeAccessModifier &&
5513 EnumTrailingComma == R.EnumTrailingComma &&
5514 ExperimentalAutoDetectBinPacking ==
5515 R.ExperimentalAutoDetectBinPacking &&
5516 FixNamespaceComments == R.FixNamespaceComments &&
5517 ForEachMacros == R.ForEachMacros &&
5519 IncludeStyle.IncludeCategories == R.IncludeStyle.IncludeCategories &&
5521 R.IncludeStyle.IncludeIsMainRegex &&
5523 R.IncludeStyle.IncludeIsMainSourceRegex &&
5524 IncludeStyle.MainIncludeChar == R.IncludeStyle.MainIncludeChar &&
5525 IndentAccessModifiers == R.IndentAccessModifiers &&
5526 IndentCaseBlocks == R.IndentCaseBlocks &&
5527 IndentCaseLabels == R.IndentCaseLabels &&
5528 IndentExportBlock == R.IndentExportBlock &&
5529 IndentExternBlock == R.IndentExternBlock &&
5530 IndentGotoLabels == R.IndentGotoLabels &&
5531 IndentPPDirectives == R.IndentPPDirectives &&
5532 IndentRequiresClause == R.IndentRequiresClause &&
5533 IndentWidth == R.IndentWidth &&
5534 IndentWrappedFunctionNames == R.IndentWrappedFunctionNames &&
5535 InsertBraces == R.InsertBraces &&
5536 InsertNewlineAtEOF == R.InsertNewlineAtEOF &&
5547 R.MacrosSkippedByRemoveParentheses &&
5555 R.ObjCBreakBeforeNestedBlockParam &&
5563 R.PenaltyBreakBeforeFirstCallParameter &&
5571 R.PenaltyBreakTemplateDeclaration &&
5581 R.RemoveEmptyLinesInUnwrappedLines &&
5599 R.SpaceBeforeCtorInitializerColon &&
5606 R.SpaceBeforeRangeBasedForLoopColon &&
5613 R.SpacesInLineCommentPrefix.Minimum &&
5615 R.SpacesInLineCommentPrefix.Maximum &&
5623 R.TableGenBreakingDAGArgOperators &&
5629 R.VerilogBreakBetweenInstancePorts &&
5644 typedef std::map<LanguageKind, FormatStyle>
MapType;
5659 std::shared_ptr<MapType> Styles;
5663 const FormatStyle &MainStyle,
5664 const std::vector<FormatStyle> &ConfigurationStyles);
5669 friend std::error_code
5671 bool AllowUnknownOptions,
5672 llvm::SourceMgr::DiagHandlerTy DiagHandler,
5673 void *DiagHandlerCtxt,
bool IsDotHFile);
5719 FormatStyle *Style);
5737 bool AllowUnknownOptions =
false,
5738 llvm::SourceMgr::DiagHandlerTy DiagHandler =
nullptr,
5739 void *DiagHandlerCtx =
nullptr,
bool IsDotHFile =
false);
5743 bool AllowUnknownOptions =
false,
5744 bool IsDotHFile =
false) {
5746 AllowUnknownOptions,
nullptr,
5747 nullptr, IsDotHFile);
5755tooling::Replacements
sortIncludes(
const FormatStyle &Style, StringRef Code,
5758 unsigned *Cursor =
nullptr);
5765 const FormatStyle &Style);
5782 const FormatStyle &Style);
5807tooling::Replacements
reformat(
const FormatStyle &Style, StringRef Code,
5815tooling::Replacements
reformat(
const FormatStyle &Style, StringRef Code,
5817 StringRef
FileName,
bool *IncompleteFormat);
5823tooling::Replacements
cleanup(
const FormatStyle &Style, StringRef Code,
5906 StringRef Code =
"", llvm::vfs::FileSystem *FS =
nullptr,
5907 bool AllowUnknownOptions =
false,
5908 llvm::SourceMgr::DiagHandlerTy DiagHandler =
nullptr);
5917 case FormatStyle::LK_C:
5919 case FormatStyle::LK_Cpp:
5921 case FormatStyle::LK_CSharp:
5923 case FormatStyle::LK_ObjC:
5924 return "Objective-C";
5925 case FormatStyle::LK_Java:
5927 case FormatStyle::LK_JavaScript:
5928 return "JavaScript";
5929 case FormatStyle::LK_Json:
5931 case FormatStyle::LK_Proto:
5933 case FormatStyle::LK_TableGen:
5935 case FormatStyle::LK_TextProto:
5937 case FormatStyle::LK_Verilog:
5951struct std::is_error_code_enum<
clang::format::ParseError> : std::true_type {};
Defines the clang::LangOptions interface.
bool operator!=(const CommonEntityInfo &LHS, const CommonEntityInfo &RHS)
The JSON file list parser is used to communicate input to InstallAPI.
unsigned TabWidth
The number of columns used for tab stops.
unsigned ObjCBlockIndentWidth
The number of characters to use for indentation of ObjC blocks.
bool ObjCBreakBeforeNestedBlockParam
Break parameters list into lines when there is nested block parameters in a function call.
bool SpaceAfterTemplateKeyword
If true, a space will be inserted after the template keyword.
WrapNamespaceBodyWithEmptyLinesStyle WrapNamespaceBodyWithEmptyLines
Wrap namespace body with empty lines.
ReferenceAlignmentStyle ReferenceAlignment
Reference alignment style (overrides PointerAlignment for references).
ReflowCommentsStyle
Types of comment reflow style.
@ RCS_IndentOnly
Only apply indentation rules, moving comments left or right, without changing formatting inside the c...
@ RCS_Always
Apply indentation rules and reflow long comments into new lines, trying to obey the ColumnLimit.
@ RCS_Never
Leave comments untouched.
int PPIndentWidth
The number of columns to use for indentation of preprocessor statements. When set to -1 (default) Ind...
SeparateDefinitionStyle
The style if definition blocks should be separated.
@ SDS_Never
Remove any empty line between definition blocks.
@ SDS_Always
Insert an empty line between definition blocks.
@ SDS_Leave
Leave definition blocks as they are.
SpacesInParensStyle SpacesInParens
If true, spaces will be inserted after ( and before ). This option is deprecated. The previous behavi...
bool isJavaScript() const
DAGArgStyle
Different ways to control the format inside TableGen DAGArg.
@ DAS_BreakAll
Break inside DAGArg after the operator and the all elements.
@ DAS_DontBreak
Never break inside DAGArg.
@ DAS_BreakElements
Break inside DAGArg after each list element but for the last. This aligns to the first element.
bool VerilogBreakBetweenInstancePorts
For Verilog, put each port on its own line in module instantiations.
std::vector< std::string > JavaImportGroups
A vector of prefixes ordered by the desired groups for Java imports.
unsigned PenaltyBreakTemplateDeclaration
The penalty for breaking after template declaration.
SortJavaStaticImportOptions SortJavaStaticImport
When sorting Java imports, by default static imports are placed before non-static imports....
RequiresClausePositionStyle
The possible positions for the requires clause. The IndentRequires option is only used if the require...
@ RCPS_WithPreceding
Try to put the clause together with the preceding part of a declaration. For class templates: stick t...
@ RCPS_SingleLine
Try to put everything in the same line if possible. Otherwise normal line breaking rules take over.
@ RCPS_OwnLineWithBrace
As with OwnLine, except, unless otherwise prohibited, place a following open brace (of a function def...
@ RCPS_OwnLine
Always put the requires clause on its own line (possibly followed by a semicolon).
@ RCPS_WithFollowing
Try to put the requires clause together with the class or function declaration.
std::vector< RawStringFormat > RawStringFormats
Defines hints for detecting supported languages code blocks in raw strings.
UseTabStyle
This option is deprecated. See LF and CRLF of LineEnding.
@ UT_ForContinuationAndIndentation
Fill all leading whitespace with tabs, and use spaces for alignment that appears within a line (e....
@ UT_ForIndentation
Use tabs only for indentation.
@ UT_Always
Use tabs whenever we need to fill whitespace that spans at least from one tab stop to the next one.
@ UT_AlignWithSpaces
Use tabs for line continuation and indentation, and spaces for alignment.
LanguageStandard Standard
Parse and format C++ constructs compatible with this standard.
PointerAlignmentStyle
The &, && and * alignment style.
@ PAS_Right
Align pointer to the right.
@ PAS_Middle
Align pointer in the middle.
@ PAS_Left
Align pointer to the left.
SpaceBeforeParensCustom SpaceBeforeParensOptions
Control of individual space before parentheses.
std::vector< std::string > Macros
A list of macros of the form <definition>=<expansion> .
RequiresExpressionIndentationKind RequiresExpressionIndentation
The indentation used for requires expression bodies.
SpaceInEmptyBracesStyle SpaceInEmptyBraces
Specifies when to insert a space in empty braces.
SpacesInLineComment SpacesInLineCommentPrefix
How many spaces are allowed at the start of a line comment. To disable the maximum set it to -1,...
bool SkipMacroDefinitionBody
Do not format macro definition body.
PointerAlignmentStyle PointerAlignment
Pointer and reference alignment style.
std::optional< FormatStyle > GetLanguageStyle(LanguageKind Language) const
PackConstructorInitializersStyle
Different ways to try to fit all constructor initializers on a line.
@ PCIS_CurrentLine
Put all constructor initializers on the current line if they fit. Otherwise, put each one on its own ...
@ PCIS_Never
Always put each constructor initializer on its own line.
@ PCIS_BinPack
Bin-pack constructor initializers.
@ PCIS_NextLine
Same as PCIS_CurrentLine except that if all constructor initializers do not fit on the current line,...
@ PCIS_NextLineOnly
Put all constructor initializers on the next line if they fit. Otherwise, put each one on its own lin...
bool SpaceBeforeRangeBasedForLoopColon
If false, spaces will be removed before range-based for loop colon.
unsigned PenaltyReturnTypeOnItsOwnLine
Penalty for putting the return type of a function onto its own line.
bool SpaceBeforeCaseColon
If false, spaces will be removed before case colon.
std::vector< std::string > StatementAttributeLikeMacros
Macros which are ignored in front of a statement, as if they were an attribute. So that they are not ...
SpacesInParensStyle
Different ways to put a space before opening and closing parentheses.
@ SIPO_Never
Never put a space in parentheses.
@ SIPO_Custom
Configure each individual space in parentheses in SpacesInParensOptions.
bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)
JavaScriptQuoteStyle JavaScriptQuotes
The JavaScriptQuoteStyle to use for JavaScript strings.
NumericLiteralComponentStyle
Control over each component in a numeric literal.
@ NLCS_Leave
Leave this component of the literal as is.
@ NLCS_Upper
Format this component with uppercase characters.
@ NLCS_Lower
Format this component with lowercase characters.
RequiresExpressionIndentationKind
Indentation logic for requires expression bodies.
@ REI_Keyword
Align requires expression body relative to the requires keyword.
@ REI_OuterScope
Align requires expression body relative to the indentation level of the outer scope the requires expr...
SpaceBeforeParensStyle
Different ways to put a space before opening parentheses.
@ SBPO_ControlStatementsExceptControlMacros
Same as SBPO_ControlStatements except this option doesn't apply to ForEach and If macros....
@ SBPO_ControlStatements
Put a space before opening parentheses only after control statement keywords (for/if/while....
@ SBPO_Always
Always put a space before opening parentheses, except when it's prohibited by the syntax rules (in fu...
@ SBPO_Never
This is deprecated and replaced by Custom below, with all SpaceBeforeParensOptions but AfterPlacement...
@ SBPO_Custom
Configure each individual space before parentheses in SpaceBeforeParensOptions.
@ SBPO_NonEmptyParentheses
Put a space before opening parentheses only if the parentheses are not empty.
std::vector< std::string > WhitespaceSensitiveMacros
A vector of macros which are whitespace-sensitive and should not be touched.
bool SpaceAfterOperatorKeyword
If true, a space will be inserted after the operator keyword.
bool ObjCSpaceAfterProperty
Add a space after @property in Objective-C, i.e. use @property (readonly) instead of @property(readon...
ReflowCommentsStyle ReflowComments
Comment reformatting style.
std::vector< std::string > TypeNames
A vector of non-keyword identifiers that should be interpreted as type names.
LineEndingStyle
Line ending style.
@ LE_DeriveCRLF
Use \r\n unless the input has more lines ending in \n.
@ LE_DeriveLF
Use \n unless the input has more lines ending in \r\n.
SpacesInAnglesStyle
Styles for adding spacing after < and before > in template argument lists.
@ SIAS_Always
Add spaces after < and before >.
@ SIAS_Never
Remove spaces after < and before >.
@ SIAS_Leave
Keep a single space after < and before > if any spaces were present. Option Standard: Cpp03 takes pre...
IntegerLiteralSeparatorStyle IntegerLiteralSeparator
Format integer literal separators (' for C++ and _ for C#, Java, and JavaScript).
std::vector< std::string > TableGenBreakingDAGArgOperators
Works only when TableGenBreakInsideDAGArg is not DontBreak. The string list needs to consist of ident...
bool SpaceBeforeCpp11BracedList
If true, a space will be inserted before a C++11 braced list used to initialize an object (after the ...
unsigned PenaltyExcessCharacter
The penalty for each character outside of the column limit.
SortJavaStaticImportOptions
Position for Java Static imports.
@ SJSIO_After
Static imports are placed after non-static imports.
@ SJSIO_Before
Static imports are placed before non-static imports.
NamespaceIndentationKind NamespaceIndentation
The indentation used for namespaces.
bool SpaceBeforeSquareBrackets
If true, spaces will be before [. Lambdas will not be affected. Only the first [ will get a space add...
bool RemoveSemicolon
Remove semicolons after the closing braces of functions and constructors/destructors.
Language
The language for the input, used to select and validate the language standard and possible actions.
bool SpaceBeforeAssignmentOperators
If false, spaces will be removed before assignment operators.
unsigned PenaltyBreakComment
The penalty for each line break introduced inside a comment.
QualifierAlignmentStyle
Different specifiers and qualifiers alignment styles.
@ QAS_Custom
Change specifiers/qualifiers to be aligned based on QualifierOrder. With:
@ QAS_Leave
Don't change specifiers/qualifiers to either Left or Right alignment (default).
@ QAS_Left
Change specifiers/qualifiers to be left-aligned.
@ QAS_Right
Change specifiers/qualifiers to be right-aligned.
SpacesInParensCustom SpacesInParensOptions
Control of individual spaces in parentheses.
SpacesInAnglesStyle SpacesInAngles
The SpacesInAnglesStyle to use for template argument lists.
BinPackStyle ObjCBinPackProtocolList
Controls bin-packing Objective-C protocol conformance list items into as few lines as possible when t...
bool ObjCSpaceBeforeProtocolList
Add a space in front of an Objective-C protocol list, i.e. use Foo <Protocol> instead of Foo<Protocol...
bool SpacesInContainerLiterals
If true, spaces will be inserted around if/for/switch/while conditions. This option is deprecated....
std::string OneLineFormatOffRegex
A regular expression that describes markers for turning formatting off for one line....
RemoveParenthesesStyle RemoveParentheses
Remove redundant parentheses.
UseTabStyle UseTab
The way to use tab characters in the resulting file.
std::vector< std::string > ObjCPropertyAttributeOrder
The order in which ObjC property attributes should appear.
std::string MacroBlockBegin
A regular expression matching macros that start a block.
unsigned PenaltyBreakString
The penalty for each line break introduced inside a string literal.
unsigned PenaltyBreakOpenParenthesis
The penalty for breaking after (.
WrapNamespaceBodyWithEmptyLinesStyle
Different styles for wrapping namespace body with empty lines.
@ WNBWELS_Never
Remove all empty lines at the beginning and the end of namespace body.
@ WNBWELS_Always
Always have at least one empty line at the beginning and the end of namespace body except that the nu...
@ WNBWELS_Leave
Keep existing newlines at the beginning and the end of namespace body. MaxEmptyLinesToKeep still appl...
unsigned PenaltyBreakBeforeFirstCallParameter
The penalty for breaking a function call after call(.
LambdaBodyIndentationKind
Indentation logic for lambda bodies.
@ LBI_Signature
Align lambda body relative to the lambda signature. This is the default.
@ LBI_OuterScope
For statements within block scope, align lambda body relative to the indentation level of the outer s...
unsigned PenaltyBreakFirstLessLess
The penalty for breaking before the first <<.
std::vector< std::string > MacrosSkippedByRemoveParentheses
A vector of function-like macros whose invocations should be skipped by RemoveParentheses.
RequiresClausePositionStyle RequiresClausePosition
The position of the requires clause.
bool SpaceBeforeJsonColon
If true, a space will be added before a JSON colon. For other languages, e.g. JavaScript,...
bool JavaScriptWrapImports
Whether to wrap JavaScript import/export statements.
bool SpaceBeforeInheritanceColon
If false, spaces will be removed before inheritance colon.
SpaceInEmptyBracesStyle
This option is deprecated. See Block of SpaceInEmptyBraces.
@ SIEB_Block
Only insert a space in empty blocks.
@ SIEB_Always
Always insert a space in empty braces.
@ SIEB_Never
Never insert a space in empty braces.
std::vector< std::string > TypenameMacros
A vector of macros that should be interpreted as type declarations instead of as function calls.
LanguageStandard
Supported language standards for parsing and formatting C++ constructs.
@ LS_Cpp03
Parse and format as C++03. Cpp03 is a deprecated alias for c++03
@ LS_Cpp14
Parse and format as C++14.
@ LS_Cpp17
Parse and format as C++17.
@ LS_Cpp11
Parse and format as C++11.
@ LS_Auto
Automatic detection based on the input.
@ LS_Latest
Parse and format using the latest supported language version. Cpp11 is a deprecated alias for Latest
@ LS_Cpp20
Parse and format as C++20.
KeepEmptyLinesStyle KeepEmptyLines
Which empty lines are kept. See MaxEmptyLinesToKeep for how many consecutive empty lines are kept.
SortUsingDeclarationsOptions
Using declaration sorting options.
@ SUD_LexicographicNumeric
Using declarations are sorted in the order defined as follows: Split the strings by :: and discard an...
@ SUD_Never
Using declarations are never sorted.
@ SUD_Lexicographic
Using declarations are sorted in the order defined as follows: Split the strings by :: and discard an...
unsigned PenaltyBreakScopeResolution
The penalty for breaking after ::.
DAGArgStyle TableGenBreakInsideDAGArg
The styles of the line break inside the DAGArg in TableGen.
LambdaBodyIndentationKind LambdaBodyIndentation
The indentation style of lambda bodies. Signature (the default) causes the lambda body to be indented...
NamespaceIndentationKind
Different ways to indent namespace contents.
@ NI_None
Don't indent in namespaces.
@ NI_All
Indent in all namespaces.
@ NI_Inner
Indent only in inner namespaces (nested in other namespaces).
SeparateDefinitionStyle SeparateDefinitionBlocks
Specifies the use of empty lines to separate definition blocks, including classes,...
bool SpaceAfterCStyleCast
If true, a space is inserted after C style casts.
SpaceAroundPointerQualifiersStyle SpaceAroundPointerQualifiers
Defines in which cases to put a space before or after pointer qualifiers.
SpaceAroundPointerQualifiersStyle
Different ways to put a space before opening parentheses.
@ SAPQ_Both
Ensure that there is a space both before and after pointer qualifiers.
@ SAPQ_Default
Don't ensure spaces around pointer qualifiers and use PointerAlignment instead.
@ SAPQ_Before
Ensure that there is a space before pointer qualifiers.
@ SAPQ_After
Ensure that there is a space after pointer qualifiers.
std::vector< std::string > TemplateNames
A vector of non-keyword identifiers that should be interpreted as template names.
bool SpacesInSquareBrackets
If true, spaces will be inserted after [ and before ]. Lambdas without arguments or unspecified size ...
std::vector< std::string > StatementMacros
A vector of macros that should be interpreted as complete statements.
RemoveParenthesesStyle
Types of redundant parentheses to remove.
@ RPS_ReturnStatement
Also remove parentheses enclosing the expression in a return/co_return statement.
@ RPS_MultipleParentheses
Replace multiple parentheses with single parentheses.
@ RPS_Leave
Do not remove parentheses.
std::vector< std::string > NamespaceMacros
A vector of macros which are used to open namespace blocks.
unsigned PenaltyBreakBeforeMemberAccess
The penalty for breaking before a member access operator (., ->).
LineEndingStyle LineEnding
Line ending style (\n or \r\n) to use.
unsigned SpacesBeforeTrailingComments
If true, spaces may be inserted into (). This option is deprecated. See InEmptyParentheses of SpacesI...
bool RemoveEmptyLinesInUnwrappedLines
Remove empty lines within unwrapped lines.
unsigned MaxEmptyLinesToKeep
The maximum number of consecutive empty lines to keep.
PackConstructorInitializersStyle PackConstructorInitializers
The pack constructor initializers style to use.
SortIncludesOptions SortIncludes
Controls if and how clang-format will sort #includes.
bool SpaceAfterLogicalNot
If true, a space is inserted after the logical not operator (!).
bool KeepFormFeed
This option is deprecated. See AtEndOfFile of KeepEmptyLines.
std::string MacroBlockEnd
A regular expression matching macros that end a block.
unsigned ShortNamespaceLines
The maximal number of unwrapped lines that a short namespace spans. Defaults to 1.
std::vector< std::string > QualifierOrder
The order in which the qualifiers appear. The order is an array that can contain any of the following...
bool RemoveBracesLLVM
Remove optional braces of control statements (if, else, for, and while) in C++ according to the LLVM ...
ReferenceAlignmentStyle
The & and && alignment style.
@ RAS_Middle
Align reference in the middle.
@ RAS_Right
Align reference to the right.
@ RAS_Pointer
Align reference like PointerAlignment.
@ RAS_Left
Align reference to the left.
bool SpaceBeforeCtorInitializerColon
If false, spaces will be removed before constructor initializer colon.
unsigned PenaltyBreakAssignment
The penalty for breaking around an assignment operator.
QualifierAlignmentStyle QualifierAlignment
Different ways to arrange specifiers and qualifiers (e.g. const/volatile).
LanguageKind
Supported languages.
@ LK_Java
Should be used for Java.
@ LK_Cpp
Should be used for C++.
@ LK_TableGen
Should be used for TableGen code.
@ LK_ObjC
Should be used for Objective-C, Objective-C++.
@ LK_CSharp
Should be used for C#.
@ LK_TextProto
Should be used for Protocol Buffer messages in text format (https://developers.google....
@ LK_Json
Should be used for JSON.
@ LK_JavaScript
Should be used for JavaScript.
@ LK_Verilog
Should be used for Verilog and SystemVerilog. https://standards.ieee.org/ieee/1800/6700/ https://sci-...
@ LK_C
Should be used for C.
@ LK_Proto
Should be used for Protocol Buffers (https://developers.google.com/protocol-buffers/).
@ Other
Other implicit parameter.
std::vector< std::string > VariableTemplates
A vector of non-keyword identifiers that should be interpreted as variable template names.
SortUsingDeclarationsOptions SortUsingDeclarations
Controls if and how clang-format will sort using declarations.
unsigned PenaltyIndentedWhitespace
Penalty for each character of whitespace indentation (counted relative to leading non-whitespace colu...
static FormatStyleSet BuildStyleSetFromConfiguration(const FormatStyle &MainStyle, const std::vector< FormatStyle > &ConfigurationStyles)
NumericLiteralCaseStyle NumericLiteralCase
Capitalization style for numeric literals.
JavaScriptQuoteStyle
Quotation styles for JavaScript strings. Does not affect template strings.
@ JSQS_Double
Always use double quotes.
@ JSQS_Leave
Leave string quotes as they are.
@ JSQS_Single
Always use single quotes.
SpaceBeforeParensStyle SpaceBeforeParens
Defines in which cases to put a space before opening parentheses.
Diagnostic wrappers for TextAPI types for error reporting.
Style for sorting and grouping C++ include directives.
IncludeBlocksStyle IncludeBlocks
Dependent on the value, multiple #include blocks can be sorted as one and divided based on category.
Options regarding which empty lines are kept.
bool AtStartOfBlock
Keep empty lines at start of a block.
bool AtStartOfFile
Keep empty lines at start of file.
bool AtEndOfFile
Keep empty lines at end of file.
bool operator==(const KeepEmptyLinesStyle &R) const
Separate control for each numeric literal component.
bool operator==(const NumericLiteralCaseStyle &R) const
bool operator!=(const NumericLiteralCaseStyle &R) const
NumericLiteralComponentStyle ExponentLetter
Format floating point exponent separator letter case.
NumericLiteralComponentStyle Suffix
Format suffix case. This option excludes case-sensitive reserved suffixes, such as min in C++.
NumericLiteralComponentStyle Prefix
Format integer prefix case.
NumericLiteralComponentStyle HexDigit
Format hexadecimal digit case.
Includes sorting options.
bool operator!=(const SortIncludesOptions &R) const
bool IgnoreCase
Whether or not includes are sorted in a case-insensitive fashion. (CaseSensitive and CaseInsensitive ...
bool IgnoreExtension
When sorting includes in each block, only take file extensions into account if two includes compare e...
bool operator==(const SortIncludesOptions &R) const
bool Enabled
If true, includes are sorted based on the other suboptions below. (Never is deprecated by Enabled: fa...
Precise control over the spacing before parentheses.
bool AfterFunctionDefinitionName
If true, put a space between function definition name and opening parentheses.
bool AfterIfMacros
If true, put space between if macros and opening parentheses.
bool AfterForeachMacros
If true, put space between foreach macros and opening parentheses.
bool AfterFunctionDeclarationName
If true, put a space between function declaration name and opening parentheses.
bool operator==(const SpaceBeforeParensCustom &Other) const
bool AfterControlStatements
If true, put space between control statement keywords (for/if/while...) and opening parentheses.
bool BeforeNonEmptyParentheses
If true, put a space before opening parentheses only if the parentheses are not empty.
bool AfterPlacementOperator
If true, put a space between operator new/delete and opening parenthesis.
bool AfterRequiresInExpression
If true, put space between requires keyword in a requires expression and opening parentheses.
bool AfterNot
If true, put a space between alternative operator not and the opening parenthesis.
bool AfterRequiresInClause
If true, put space between requires keyword in a requires clause and opening parentheses,...
SpaceBeforeParensCustom()
bool AfterOverloadedOperator
If true, put a space between operator overloading and opening parentheses.
Precise control over the spacing in parentheses.
bool Other
Put a space in parentheses not covered by preceding options.
bool InCStyleCasts
Put a space in C style casts.
bool operator!=(const SpacesInParensCustom &R) const
bool InConditionalStatements
Put a space in parentheses only inside conditional statements (for/if/while/switch....
bool InEmptyParentheses
Insert a space in empty parentheses, i.e. ().
bool ExceptDoubleParentheses
Override any of the following options to prevent addition of space when both opening and closing pare...
SpacesInParensCustom(bool ExceptDoubleParentheses, bool InConditionalStatements, bool InCStyleCasts, bool InEmptyParentheses, bool Other)
bool operator==(const SpacesInParensCustom &R) const