FormatStyle Struct Reference

The FormatStyle is used to configure the formatting to follow specific guidelines. More...

#include "clang/Format/Format.h"

Classes
struct	AlignConsecutiveStyle
	Alignment options. More...
struct	BinaryOperationBreakRule
	A rule that specifies how to break a specific set of binary operators. More...
struct	BraceWrappingFlags
	Precise control over the wrapping of braces. More...
struct	BreakBinaryOperationsOptions
	Options for BreakBinaryOperations. More...
struct	FormatStyleSet
struct	IntegerLiteralSeparatorStyle
	Separator format of integer literals of different bases. More...
struct	KeepEmptyLinesStyle
	Options regarding which empty lines are kept. More...
struct	NumericLiteralCaseStyle
	Separate control for each numeric literal component. More...
struct	PackArgumentsStyle
	Options related to packing arguments of function calls. More...
struct	PackParametersStyle
	Options related to packing parameters of function declarations and definitions. More...
struct	RawStringFormat
	See documentation of RawStringFormats. More...
struct	ShortCaseStatementsAlignmentStyle
	Alignment options. More...
struct	ShortFunctionStyle
	Different styles for merging short functions containing at most one statement. More...
struct	SortIncludesOptions
	Includes sorting options. More...
struct	SpaceBeforeParensCustom
	Precise control over the spacing before parentheses. More...
struct	SpacesInLineComment
	If true, spaces may be inserted into C style casts. More...
struct	SpacesInParensCustom
	Precise control over the spacing in parentheses. More...
struct	TrailingCommentsAlignmentStyle
	Alignment options. More...

Public Types
enum	ArrayInitializerAlignmentStyle : int8_t { AIAS_Left , AIAS_Right , AIAS_None }
	Different style for aligning array initializers. More...
enum	EscapedNewlineAlignmentStyle : int8_t { ENAS_DontAlign , ENAS_Left , ENAS_LeftWithLastLine , ENAS_Right }
	Different styles for aligning escaped newlines. More...
enum	OperandAlignmentStyle : int8_t { OAS_DontAlign , OAS_Align , OAS_AlignAfterOperator }
	Different styles for aligning operands. More...
enum	TrailingCommentsAlignmentKinds : int8_t { TCAS_Leave , TCAS_Always , TCAS_Never }
	Enums for AlignTrailingComments. More...
enum	BreakBeforeNoexceptSpecifierStyle : int8_t { BBNSS_Never , BBNSS_OnlyWithParen , BBNSS_Always }
	Different ways to break before a noexcept specifier. More...
enum	ShortBlockStyle : int8_t { SBS_Never , SBS_Empty , SBS_Always }
	Different styles for merging short blocks containing at most one statement. More...
enum	ShortIfStyle : int8_t { SIS_Never , SIS_WithoutElse , SIS_OnlyFirstIf , SIS_AllIfsAndElse }
	Different styles for handling short if statements. More...
enum	ShortLambdaStyle : int8_t { SLS_None , SLS_Empty , SLS_Inline , SLS_All }
	Different styles for merging short lambdas containing at most one statement. More...
enum	ShortRecordStyle : int8_t { SRS_Never , SRS_EmptyAndAttached , SRS_Empty , SRS_Always }
	Different styles for merging short records (class,struct, and union). More...
enum	DefinitionReturnTypeBreakingStyle : int8_t { DRTBS_None , DRTBS_All , DRTBS_TopLevel }
	Different ways to break after the function definition return type. More...
enum	ReturnTypeBreakingStyle : int8_t {   RTBS_None , RTBS_Automatic , RTBS_ExceptShortType , RTBS_All ,   RTBS_TopLevel , RTBS_AllDefinitions , RTBS_TopLevelDefinitions }
	Different ways to break after the function definition or declaration return type. More...
enum	BreakTemplateDeclarationsStyle : int8_t { BTDS_Leave , BTDS_No , BTDS_MultiLine , BTDS_Yes }
	Different ways to break after the template declaration. More...
enum	BitFieldColonSpacingStyle : int8_t { BFCS_Both , BFCS_None , BFCS_Before , BFCS_After }
	This option is deprecated. More...
enum	BraceWrappingAfterControlStatementStyle : int8_t { BWACS_Never , BWACS_MultiLine , BWACS_Always }
	Different ways to wrap braces after control statements. More...
enum	AttributeBreakingStyle : int8_t { ABS_Always , ABS_Leave , ABS_LeaveAll , ABS_Never }
	Different ways to break after the last attribute of a group before a declaration or control statement. More...
enum	BinPackStyle : int8_t { BPS_Auto , BPS_Always , BPS_Never }
	The style of wrapping parameters on the same line (bin-packed) or on one line each. More...
enum	BinaryOperatorStyle : int8_t { BOS_None , BOS_NonAssignment , BOS_All }
	The style of breaking before or after binary operators. More...
enum	BraceBreakingStyle : int8_t {   BS_Attach , BS_Linux , BS_Mozilla , BS_Stroustrup ,   BS_Allman , BS_Whitesmiths , BS_GNU , BS_WebKit ,   BS_Custom }
	Different ways to attach braces to their surrounding context. More...
enum	BreakBeforeConceptDeclarationsStyle : int8_t { BBCDS_Never , BBCDS_Allowed , BBCDS_Always }
	Different ways to break before concept declarations. More...
enum	BreakBeforeInlineASMColonStyle : int8_t { BBIAS_Never , BBIAS_OnlyMultiline , BBIAS_Always }
	Different ways to break ASM parameters. More...
enum	BreakBeforeReturnTypeStyle : int8_t {   BBRTS_None , BBRTS_All , BBRTS_TopLevel , BBRTS_AllDefinitions ,   BBRTS_TopLevelDefinitions }
	Different ways to break before the function return type. More...
enum	BreakBinaryOperationsStyle : int8_t { BBO_Never , BBO_OnePerLine , BBO_RespectPrecedence }
	Different ways to break binary operations. More...
enum	BreakConstructorInitializersStyle : int8_t { BCIS_BeforeColon , BCIS_BeforeComma , BCIS_AfterColon , BCIS_AfterComma }
	Different ways to break initializers. More...
enum	BreakInheritanceListStyle : int8_t { BILS_BeforeColon , BILS_BeforeComma , BILS_AfterColon , BILS_AfterComma }
	Different ways to break inheritance list. More...
enum	BracedListStyle : int8_t { BLS_Block , BLS_FunctionCall , BLS_AlignFirstComment }
	Different ways to handle braced lists. More...
enum	EmptyLineAfterAccessModifierStyle : int8_t { ELAAMS_Never , ELAAMS_Leave , ELAAMS_Always }
	Different styles for empty line after access modifiers. More...
enum	EmptyLineBeforeAccessModifierStyle : int8_t { ELBAMS_Never , ELBAMS_Leave , ELBAMS_LogicalBlock , ELBAMS_Always }
	Different styles for empty line before access modifiers. More...
enum	EnumTrailingCommaStyle : int8_t { ETC_Leave , ETC_Insert , ETC_Remove }
	Styles for enum trailing commas. More...
enum	IndentExternBlockStyle : int8_t { IEBS_AfterExternBlock , IEBS_NoIndent , IEBS_Indent }
	Indents extern blocks. More...
enum	IndentGotoLabelStyle : int8_t { IGLS_NoIndent , IGLS_OuterIndent , IGLS_InnerIndent , IGLS_HalfIndent }
	Options for indenting goto labels. More...
enum	PPDirectiveIndentStyle : int8_t { PPDIS_None , PPDIS_AfterHash , PPDIS_BeforeHash , PPDIS_Leave }
	Options for indenting preprocessor directives. More...
enum	TrailingCommaStyle : int8_t { TCS_None , TCS_Wrapped }
	The style of inserting trailing commas into container literals. More...
enum	JavaScriptQuoteStyle : int8_t { JSQS_Leave , JSQS_Single , JSQS_Double }
	Quotation styles for JavaScript strings. More...
enum	LambdaBodyIndentationKind : int8_t { LBI_Signature , LBI_OuterScope }
	Indentation logic for lambda bodies. More...
enum	LanguageKind : int8_t {   LK_None , LK_C , LK_Cpp , LK_CSharp ,   LK_Java , LK_JavaScript , LK_Json , LK_ObjC ,   LK_Proto , LK_TableGen , LK_TextProto , LK_Verilog }
	Supported languages. More...
enum	LineEndingStyle : int8_t { LE_LF , LE_CRLF , LE_DeriveLF , LE_DeriveCRLF }
	Line ending style. More...
enum	NamespaceIndentationKind : int8_t { NI_None , NI_Inner , NI_All }
	Different ways to indent namespace contents. More...
enum	NumericLiteralComponentStyle : int8_t { NLCS_Leave , NLCS_Upper , NLCS_Lower }
	Control over each component in a numeric literal. More...
enum	BinPackArgumentsStyle : int8_t { BPAS_BinPack , BPAS_OnePerLine , BPAS_UseBreakAfter }
	Different ways to try to fit all arguments on a line. More...
enum	PackConstructorInitializersStyle : int8_t {   PCIS_Never , PCIS_BinPack , PCIS_CurrentLine , PCIS_NextLine ,   PCIS_NextLineOnly }
	Different ways to try to fit all constructor initializers on a line. More...
enum	BinPackParametersStyle : int8_t { BPPS_BinPack , BPPS_OnePerLine , BPPS_AlwaysOnePerLine , BPPS_UseBreakAfter }
	Different ways to try to fit all parameters on a line. More...
enum	PointerAlignmentStyle : int8_t { PAS_Left , PAS_Right , PAS_Middle }
	The &, && and * alignment style. More...
enum	QualifierAlignmentStyle : int8_t { QAS_Leave , QAS_Left , QAS_Right , QAS_Custom }
	Different specifiers and qualifiers alignment styles. More...
enum	ReferenceAlignmentStyle : int8_t { RAS_Pointer , RAS_Left , RAS_Right , RAS_Middle }
	The & and && alignment style. More...
enum	ReflowCommentsStyle : int8_t { RCS_Never , RCS_IndentOnly , RCS_Always }
	Types of comment reflow style. More...
enum	RemoveParenthesesStyle : int8_t { RPS_Leave , RPS_MultipleParentheses , RPS_ReturnStatement }
	Types of redundant parentheses to remove. More...
enum	RequiresClausePositionStyle : int8_t {   RCPS_OwnLine , RCPS_OwnLineWithBrace , RCPS_WithPreceding , RCPS_WithFollowing ,   RCPS_SingleLine }
	The possible positions for the requires clause. More...
enum	RequiresExpressionIndentationKind : int8_t { REI_OuterScope , REI_Keyword }
	Indentation logic for requires expression bodies. More...
enum	SeparateDefinitionStyle : int8_t { SDS_Leave , SDS_Always , SDS_Never }
	The style if definition blocks should be separated. More...
enum	SortJavaStaticImportOptions : int8_t { SJSIO_Before , SJSIO_After }
	Position for Java Static imports. More...
enum	SortUsingDeclarationsOptions : int8_t { SUD_Never , SUD_Lexicographic , SUD_LexicographicNumeric }
	Using declaration sorting options. More...
enum	SpaceAroundPointerQualifiersStyle : int8_t { SAPQ_Default , SAPQ_Before , SAPQ_After , SAPQ_Both }
	Different ways to put a space before opening parentheses. More...
enum	SpaceBeforeParensStyle : int8_t {   SBPO_Never , SBPO_ControlStatements , SBPO_ControlStatementsExceptControlMacros , SBPO_NonEmptyParentheses ,   SBPO_Always , SBPO_Custom }
	Different ways to put a space before opening parentheses. More...
enum	SpaceInEmptyBracesStyle : int8_t { SIEB_Always , SIEB_Block , SIEB_Never }
	This option is deprecated. More...
enum	SpacesInAnglesStyle : int8_t { SIAS_Never , SIAS_Always , SIAS_Leave }
	Styles for adding spacing after < and before > in template argument lists. More...
enum	SpacesInBlockCommentsStyle : int8_t { SIBCS_Never , SIBCS_Always , SIBCS_Leave }
	Styles for controlling spacing after /* and before `. More...
enum	SpacesInParensStyle : int8_t { SIPO_Never , SIPO_Custom }
	Different ways to put a space before opening and closing parentheses. More...
enum	LanguageStandard : int8_t {   LS_Cpp03 , LS_Cpp11 , LS_Cpp14 , LS_Cpp17 ,   LS_Cpp20 , LS_Cpp23 , LS_Cpp26 , LS_Latest ,   LS_Auto }
	Supported language standards for parsing and formatting C++ constructs. More...
enum	DAGArgStyle : int8_t { DAS_DontBreak , DAS_BreakElements , DAS_BreakAll }
	Different ways to control the format inside TableGen DAGArg. More...
enum	UseTabStyle : int8_t {   UT_Never , UT_ForIndentation , UT_ForContinuationAndIndentation , UT_AlignWithSpaces ,   UT_Always }
	This option is deprecated. More...
enum	WrapNamespaceBodyWithEmptyLinesStyle : int8_t { WNBWELS_Never , WNBWELS_Always , WNBWELS_Leave }
	Different styles for wrapping namespace body with empty lines. More...

Public Member Functions
bool	isCpp () const
bool	isCSharp () const
bool	isJson () const
bool	isJava () const
bool	isJavaScript () const
bool	isVerilog () const
bool	isTextProto () const
bool	isProto () const
bool	isTableGen () const
bool	operator== (const FormatStyle &R) const
std::optional< FormatStyle >	GetLanguageStyle (LanguageKind Language) const

Static Public Member Functions
static FormatStyleSet	BuildStyleSetFromConfiguration (const FormatStyle &MainStyle, const std::vector< FormatStyle > &ConfigurationStyles)

Public Attributes
std::string	InheritConfig
int	AccessModifierOffset
	The extra indent or outdent of access modifiers, e.g.
bool	AlignAfterOpenBracket
	If true, horizontally aligns arguments after an open bracket.
ArrayInitializerAlignmentStyle	AlignArrayOfStructures
	If not None, when using initialization for an array of structs aligns the fields into columns.
AlignConsecutiveStyle	AlignConsecutiveAssignments
	Style of aligning consecutive assignments.
AlignConsecutiveStyle	AlignConsecutiveBitFields
	Style of aligning consecutive bit fields.
AlignConsecutiveStyle	AlignConsecutiveDeclarations
	Style of aligning consecutive declarations.
AlignConsecutiveStyle	AlignConsecutiveMacros
	Style of aligning consecutive macro definitions.
ShortCaseStatementsAlignmentStyle	AlignConsecutiveShortCaseStatements
	Style of aligning consecutive short case labels.
AlignConsecutiveStyle	AlignConsecutiveTableGenBreakingDAGArgColons
	Style of aligning consecutive TableGen DAGArg operator colons.
AlignConsecutiveStyle	AlignConsecutiveTableGenCondOperatorColons
	Style of aligning consecutive TableGen cond operator colons.
AlignConsecutiveStyle	AlignConsecutiveTableGenDefinitionColons
	Style of aligning consecutive TableGen definition colons.
EscapedNewlineAlignmentStyle	AlignEscapedNewlines
	Options for aligning backslashes in escaped newlines.
OperandAlignmentStyle	AlignOperands
	If true, horizontally align operands of binary and ternary expressions.
TrailingCommentsAlignmentStyle	AlignTrailingComments
	Control of trailing comments.
bool	AllowAllArgumentsOnNextLine
	If a function call or braced initializer list doesn't fit on a line, allow putting all arguments onto the next line, even if BinPackArguments is false.
bool	AllowAllParametersOfDeclarationOnNextLine
	This option is deprecated.
BreakBeforeNoexceptSpecifierStyle	AllowBreakBeforeNoexceptSpecifier
	Controls if there could be a line break before a noexcept specifier.
bool	AllowBreakBeforeQtProperty
	Allow breaking before Q_Property keywords READ, WRITE, etc.
ShortBlockStyle	AllowShortBlocksOnASingleLine
	Dependent on the value, while (true) { continue; } can be put on a single line.
bool	AllowShortCaseExpressionOnASingleLine
	Whether to merge a short switch labeled rule into a single line.
bool	AllowShortCaseLabelsOnASingleLine
	If true, short case labels will be contracted to a single line.
bool	AllowShortCompoundRequirementOnASingleLine
	Allow short compound requirement on a single line.
bool	AllowShortEnumsOnASingleLine
	Allow short enums on a single line.
ShortFunctionStyle	AllowShortFunctionsOnASingleLine
	Dependent on the value, int f() { return 0; } can be put on a single line.
ShortIfStyle	AllowShortIfStatementsOnASingleLine
	Dependent on the value, if (a) return; can be put on a single line.
ShortLambdaStyle	AllowShortLambdasOnASingleLine
	Dependent on the value, auto lambda []() { return 0; } can be put on a single line.
bool	AllowShortLoopsOnASingleLine
	If true, while (true) continue; can be put on a single line.
bool	AllowShortNamespacesOnASingleLine
	If true, namespace a { class b; } can be put on a single line.
ShortRecordStyle	AllowShortRecordOnASingleLine
	Dependent on the value, struct bar { int i; }; can be put on a single line.
DefinitionReturnTypeBreakingStyle	AlwaysBreakAfterDefinitionReturnType
	The function definition return type breaking style to use.
bool	AlwaysBreakBeforeMultilineStrings
	This option is renamed to BreakAfterReturnType.
std::vector< std::string >	AttributeMacros
	This option is renamed to BreakTemplateDeclarations.
bool	BinPackLongBracedList
	This option is deprecated.
BitFieldColonSpacingStyle	BitFieldColonSpacing
	The BitFieldColonSpacingStyle to use for bitfields.
int	BracedInitializerIndentWidth
	The number of columns to use to indent the contents of braced init lists.
BraceWrappingFlags	BraceWrapping
	Control of individual brace wrapping cases.
bool	BreakAdjacentStringLiterals
	Break between adjacent string literals.
AttributeBreakingStyle	BreakAfterAttributes
	Break after a group of C++11 attributes before variable or function (including constructor/destructor) declaration/definition names or before control statements, i.e.
bool	BreakAfterOpenBracketBracedList
	Force break after the left bracket of a braced initializer list (when Cpp11BracedListStyle is true) when the list exceeds the column limit.
bool	BreakAfterOpenBracketFunction
	Force break after the left parenthesis of a function (declaration, definition, call) when the parameters exceed the column limit.
bool	BreakAfterOpenBracketIf
	Force break after the left parenthesis of an if control statement when the expression exceeds the column limit.
bool	BreakAfterOpenBracketLoop
	Force break after the left parenthesis of a loop control statement when the expression exceeds the column limit.
bool	BreakAfterOpenBracketSwitch
	Force break after the left parenthesis of a switch control statement when the expression exceeds the column limit.
ReturnTypeBreakingStyle	BreakAfterReturnType
	The function declaration return type breaking style to use.
bool	BreakArrays
	If true, clang-format will always break after a Json array [ otherwise it will scan until the closing ] to determine if it should add newlines between elements (prettier compatible).
BinaryOperatorStyle	BreakBeforeBinaryOperators
	The way to wrap binary operators.
BraceBreakingStyle	BreakBeforeBraces
	The brace breaking style to use.
bool	BreakBeforeCloseBracketBracedList
	Force break before the right bracket of a braced initializer list (when Cpp11BracedListStyle is true) when the list exceeds the column limit.
bool	BreakBeforeCloseBracketFunction
	Force break before the right parenthesis of a function (declaration, definition, call) when the parameters exceed the column limit.
bool	BreakBeforeCloseBracketIf
	Force break before the right parenthesis of an if control statement when the expression exceeds the column limit.
bool	BreakBeforeCloseBracketLoop
	Force break before the right parenthesis of a loop control statement when the expression exceeds the column limit.
bool	BreakBeforeCloseBracketSwitch
	Force break before the right parenthesis of a switch control statement when the expression exceeds the column limit.
BreakBeforeConceptDeclarationsStyle	BreakBeforeConceptDeclarations
	The concept declaration style to use.
BreakBeforeInlineASMColonStyle	BreakBeforeInlineASMColon
	The inline ASM colon style to use.
BreakBeforeReturnTypeStyle	BreakBeforeReturnType
	The function declaration/definition return type breaking style to use.
bool	BreakBeforeTemplateCloser
	If true, break before a template closing bracket (>) when there is a line break after the matching opening bracket (<).
bool	BreakBeforeTernaryOperators
	If true, ternary operators will be placed after line breaks.
BreakBinaryOperationsOptions	BreakBinaryOperations
	The break binary operations style to use.
BreakConstructorInitializersStyle	BreakConstructorInitializers
	The break constructor initializers style to use.
bool	BreakFunctionDeclarationParameters
	If true, clang-format will always break before function declaration parameters.
bool	BreakFunctionDefinitionParameters
	If true, clang-format will always break before function definition parameters.
bool	BreakAfterJavaFieldAnnotations
	Break after each annotation on a field in Java files.
bool	BreakStringLiterals
	Allow breaking string literals when formatting.
unsigned	ColumnLimit
	The column limit.
std::string	CommentPragmas
	A regular expression that describes comments with special meaning, which should not be split into lines or otherwise changed.
BreakInheritanceListStyle	BreakInheritanceList
	The inheritance list style to use.
BreakTemplateDeclarationsStyle	BreakTemplateDeclarations
	The template declaration breaking style to use.
bool	CompactNamespaces
	If true, consecutive namespace declarations will be on the same line.
unsigned	ConstructorInitializerIndentWidth
	This option is deprecated.
unsigned	ContinuationIndentWidth
	Indent width for line continuations.
BracedListStyle	Cpp11BracedListStyle
	The style to handle braced lists.
bool	DerivePointerAlignment
	This option is deprecated.
bool	DisableFormat
	Disables formatting completely.
EmptyLineAfterAccessModifierStyle	EmptyLineAfterAccessModifier
	Defines when to put an empty line after access modifiers.
EmptyLineBeforeAccessModifierStyle	EmptyLineBeforeAccessModifier
	Defines in which cases to put empty line before access modifiers.
EnumTrailingCommaStyle	EnumTrailingComma
	Insert a comma (if missing) or remove the comma at the end of an enum enumerator list.
bool	ExperimentalAutoDetectBinPacking
	If true, clang-format detects whether function calls and definitions are formatted with one parameter per line.
bool	FixNamespaceComments
	If true, clang-format adds missing namespace end comments for namespaces and fixes invalid existing ones.
std::vector< std::string >	ForEachMacros
	A vector of macros that should be interpreted as foreach loops instead of as function calls.
tooling::IncludeStyle	IncludeStyle
std::vector< std::string >	IfMacros
	A vector of macros that should be interpreted as conditionals instead of as function calls.
bool	IndentAccessModifiers
	Specify whether access modifiers should have their own indentation level.
bool	IndentCaseBlocks
	Indent case label blocks one level from the case label.
bool	IndentCaseLabels
	Indent case labels one level from the switch statement.
bool	IndentExportBlock
	If true, clang-format will indent the body of an export { ... } block.
IndentExternBlockStyle	IndentExternBlock
	IndentExternBlockStyle is the type of indenting of extern blocks.
IndentGotoLabelStyle	IndentGotoLabels
	The goto label indenting style to use.
PPDirectiveIndentStyle	IndentPPDirectives
	The preprocessor directive indenting style to use.
bool	IndentRequiresClause
	Indent the requires clause in a template.
unsigned	IndentWidth
	The number of columns to use for indentation.
bool	IndentWrappedFunctionNames
	Indent if a function definition or declaration is wrapped after the type.
bool	InsertBraces
	Insert braces after control statements (if, else, for, do, and while) in C++ unless the control statements are inside macro definitions or the braces would enclose preprocessor directives.
bool	InsertNewlineAtEOF
	Insert a newline at end of file if missing.
TrailingCommaStyle	InsertTrailingCommas
	If set to TCS_Wrapped will insert trailing commas in container literals (arrays and objects) that wrap across multiple lines.
IntegerLiteralSeparatorStyle	IntegerLiteralSeparator
	Format integer literal separators (‘’ for C/C++ and _` for C#, Java, and JavaScript).
std::vector< std::string >	JavaImportGroups
	A vector of prefixes ordered by the desired groups for Java imports.
JavaScriptQuoteStyle	JavaScriptQuotes
	The JavaScriptQuoteStyle to use for JavaScript strings.
bool	JavaScriptWrapImports
	Whether to wrap JavaScript import/export statements.
KeepEmptyLinesStyle	KeepEmptyLines
	Which empty lines are kept.
bool	KeepFormFeed
	This option is deprecated.
LambdaBodyIndentationKind	LambdaBodyIndentation
	The indentation style of lambda bodies.
LanguageKind	Language
	The language that this format style targets.
LineEndingStyle	LineEnding
	Line ending style (\n or \r\n) to use.
std::string	MacroBlockBegin
	A regular expression matching macros that start a block.
std::string	MacroBlockEnd
	A regular expression matching macros that end a block.
std::vector< std::string >	Macros
	A list of macros of the form <definition>=<expansion> .
std::vector< std::string >	MacrosSkippedByRemoveParentheses
	A vector of function-like macros whose invocations should be skipped by RemoveParentheses.
unsigned	MaxEmptyLinesToKeep
	The maximum number of consecutive empty lines to keep.
NamespaceIndentationKind	NamespaceIndentation
	The indentation used for namespaces.
std::vector< std::string >	NamespaceMacros
	A vector of macros which are used to open namespace blocks.
NumericLiteralCaseStyle	NumericLiteralCase
	Capitalization style for numeric literals.
BinPackStyle	ObjCBinPackProtocolList
	Controls bin-packing Objective-C protocol conformance list items into as few lines as possible when they go over ColumnLimit.
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.
std::vector< std::string >	ObjCPropertyAttributeOrder
	The order in which ObjC property attributes should appear.
bool	ObjCSpaceAfterMethodDeclarationPrefix
	Add or remove a space between the '-'/'+' and the return type in Objective-C method declarations.
bool	ObjCSpaceAfterProperty
	Add a space after @property in Objective-C, i.e.
bool	ObjCSpaceBeforeProtocolList
	Add a space in front of an Objective-C protocol list, i.e.
std::string	OneLineFormatOffRegex
	A regular expression that describes markers for turning formatting off for one line.
PackArgumentsStyle	PackArguments
	Options related to packing arguments of function calls.
PackConstructorInitializersStyle	PackConstructorInitializers
	The pack constructor initializers style to use.
PackParametersStyle	PackParameters
	Options related to packing parameters of function declarations and definitions.
unsigned	PenaltyBreakAssignment
	The penalty for breaking around an assignment operator.
unsigned	PenaltyBreakBeforeFirstCallParameter
	The penalty for breaking a function call after call(.
unsigned	PenaltyBreakBeforeMemberAccess
	The penalty for breaking before a member access operator (.
unsigned	PenaltyBreakComment
	The penalty for each line break introduced inside a comment.
unsigned	PenaltyBreakFirstLessLess
	The penalty for breaking before the first <<.
unsigned	PenaltyBreakOpenParenthesis
	The penalty for breaking after (.
unsigned	PenaltyBreakScopeResolution
	The penalty for breaking after ::.
unsigned	PenaltyBreakString
	The penalty for each line break introduced inside a string literal.
unsigned	PenaltyBreakTemplateDeclaration
	The penalty for breaking after template declaration.
unsigned	PenaltyExcessCharacter
	The penalty for each character outside of the column limit.
unsigned	PenaltyIndentedWhitespace
	Penalty for each character of whitespace indentation (counted relative to leading non-whitespace column).
unsigned	PenaltyReturnTypeOnItsOwnLine
	Penalty for putting the return type of a function onto its own line.
PointerAlignmentStyle	PointerAlignment
	Pointer and reference alignment style.
int	PPIndentWidth
	The number of columns to use for indentation of preprocessor statements.
QualifierAlignmentStyle	QualifierAlignment
	Different ways to arrange specifiers and qualifiers (e.g.
std::vector< std::string >	QualifierOrder
	The order in which the qualifiers appear.
std::vector< RawStringFormat >	RawStringFormats
	Defines hints for detecting supported languages code blocks in raw strings.
ReferenceAlignmentStyle	ReferenceAlignment
	Reference alignment style (overrides PointerAlignment for references).
ReflowCommentsStyle	ReflowComments
	Comment reformatting style.
bool	RemoveBracesLLVM
	Remove optional braces of control statements (if, else, for, and while) in C++ according to the LLVM coding style.
bool	RemoveEmptyLinesInUnwrappedLines
	Remove empty lines within unwrapped lines.
RemoveParenthesesStyle	RemoveParentheses
	Remove redundant parentheses.
bool	RemoveSemicolon
	Remove semicolons after the closing braces of functions and constructors/destructors.
RequiresClausePositionStyle	RequiresClausePosition
	The position of the requires clause.
RequiresExpressionIndentationKind	RequiresExpressionIndentation
	The indentation used for requires expression bodies.
SeparateDefinitionStyle	SeparateDefinitionBlocks
	Specifies the use of empty lines to separate definition blocks, including classes, structs, enums, and functions.
unsigned	ShortNamespaceLines
	The maximal number of unwrapped lines that a short namespace spans.
bool	SkipMacroDefinitionBody
	Do not format macro definition body.
SortIncludesOptions	SortIncludes
	Controls if and how clang-format will sort #includes.
SortJavaStaticImportOptions	SortJavaStaticImport
	When sorting Java imports, by default static imports are placed before non-static imports.
SortUsingDeclarationsOptions	SortUsingDeclarations
	Controls if and how clang-format will sort using declarations.
bool	SpaceAfterCStyleCast
	If true, a space is inserted after C style casts.
bool	SpaceAfterLogicalNot
	If true, a space is inserted after the logical not operator (!).
bool	SpaceAfterOperatorKeyword
	If true, a space will be inserted after the operator keyword.
bool	SpaceAfterTemplateKeyword
	If true, a space will be inserted after the template keyword.
SpaceAroundPointerQualifiersStyle	SpaceAroundPointerQualifiers
	Defines in which cases to put a space before or after pointer qualifiers.
bool	SpaceBeforeAssignmentOperators
	If false, spaces will be removed before assignment operators.
bool	SpaceBeforeCaseColon
	If false, spaces will be removed before case colon.
bool	SpaceBeforeCpp11BracedList
	If true, a space will be inserted before a C++11 braced list used to initialize an object (after the preceding identifier or type).
bool	SpaceBeforeCtorInitializerColon
	If false, spaces will be removed before constructor initializer colon.
bool	SpaceBeforeEnumUnderlyingTypeColon
	If false, spaces will be removed before enum underlying type colon.
bool	SpaceBeforeInheritanceColon
	If false, spaces will be removed before inheritance colon.
bool	SpaceBeforeJsonColon
	If true, a space will be added before a JSON colon.
SpaceBeforeParensStyle	SpaceBeforeParens
	Defines in which cases to put a space before opening parentheses.
SpaceBeforeParensCustom	SpaceBeforeParensOptions
	Control of individual space before parentheses.
bool	SpaceBeforeSquareBrackets
	If true, spaces will be before [.
bool	SpaceBeforeRangeBasedForLoopColon
	If false, spaces will be removed before range-based for loop colon.
SpaceInEmptyBracesStyle	SpaceInEmptyBraces
	Specifies when to insert a space in empty braces.
unsigned	SpacesBeforeTrailingComments
	If true, spaces may be inserted into ().
SpacesInAnglesStyle	SpacesInAngles
	The SpacesInAnglesStyle to use for template argument lists.
and *and parameter comments ending	with
	The SpacesInBlockCommentsStyle to use for ordinary block comments.
bool	SpacesInContainerLiterals
	If true, spaces will be inserted around if/for/switch/while conditions.
SpacesInLineComment	SpacesInLineCommentPrefix
	How many spaces are allowed at the start of a line comment.
SpacesInParensStyle	SpacesInParens
	If true, spaces will be inserted after ( and before ).
SpacesInParensCustom	SpacesInParensOptions
	Control of individual spaces in parentheses.
bool	SpacesInSquareBrackets
	If true, spaces will be inserted after [ and before ].
LanguageStandard	Standard
	Parse and format C++ constructs compatible with this standard.
std::vector< std::string >	StatementAttributeLikeMacros
	Macros which are ignored in front of a statement, as if they were an attribute.
std::vector< std::string >	StatementMacros
	A vector of macros that should be interpreted as complete statements.
std::vector< std::string >	TableGenBreakingDAGArgOperators
	Works only when TableGenBreakInsideDAGArg is not DontBreak.
DAGArgStyle	TableGenBreakInsideDAGArg
	The styles of the line break inside the DAGArg in TableGen.
unsigned	TabWidth
	The number of columns used for tab stops.
std::vector< std::string >	TemplateNames
	A vector of non-keyword identifiers that should be interpreted as template names.
std::vector< std::string >	TypeNames
	A vector of non-keyword identifiers that should be interpreted as type names.
std::vector< std::string >	TypenameMacros
	A vector of macros that should be interpreted as type declarations instead of as function calls.
UseTabStyle	UseTab
	The way to use tab characters in the resulting file.
std::vector< std::string >	VariableTemplates
	A vector of non-keyword identifiers that should be interpreted as variable template names.
bool	VerilogBreakBetweenInstancePorts
	For Verilog, put each port on its own line in module instantiations.
std::vector< std::string >	WhitespaceSensitiveMacros
	A vector of macros which are whitespace-sensitive and should not be touched.
WrapNamespaceBodyWithEmptyLinesStyle	WrapNamespaceBodyWithEmptyLines
	Wrap namespace body with empty lines.

Friends
std::error_code	parseConfiguration (llvm::MemoryBufferRef Config, FormatStyle *Style, bool AllowUnknownOptions=false, llvm::SourceMgr::DiagHandlerTy DiagHandler=nullptr, void *DiagHandlerCtxt=nullptr, bool IsDotHFile=false)
	Parse configuration from YAML-formatted text.

Detailed Description

The FormatStyle is used to configure the formatting to follow specific guidelines.

Definition at line 56 of file Format.h.

Member Enumeration Documentation

ArrayInitializerAlignmentStyle

enum clang::format::FormatStyle::ArrayInitializerAlignmentStyle : int8_t

Different style for aligning array initializers.

Enumerator
AIAS_Left	Align array column and left justify the columns e.g.: struct test demo[] = { {56, 23, "hello"}, {-1, 93463, "world"}, {7, 5, "!!" } };
AIAS_Right	Align array column and right justify the columns e.g.: struct test demo[] = { {56, 23, "hello"}, {-1, 93463, "world"}, { 7, 5, "!!"} };
AIAS_None	Don't align array initializer columns.

Definition at line 90 of file Format.h.

AttributeBreakingStyle

enum clang::format::FormatStyle::AttributeBreakingStyle : int8_t

Different ways to break after the last attribute of a group before a declaration or control statement.

Enumerator
ABS_Always	Always break after the last attribute of the group. [[maybe_unused]] const int i; [[gnu::const]] [[maybe_unused]] int j; [[nodiscard]] inline int f(); [[gnu::const]] [[nodiscard]] int g(); [[likely]] if (a) f(); else g(); switch (b) { [[unlikely]] case 1: ++b; break; [[likely]] default: return; }
ABS_Leave	Leave the line breaking after the last attribute of the group as is. [[maybe_unused]] const int i; [[gnu::const]] [[maybe_unused]] int j; [[nodiscard]] inline int f(); [[gnu::const]] [[nodiscard]] int g(); [[likely]] if (a) f(); else g(); switch (b) { [[unlikely]] case 1: ++b; break; [[likely]] default: return; }
ABS_LeaveAll	Same as Leave except that it applies to all attributes of the group. [[deprecated("Don't use this version")]] [[nodiscard]] bool foo() { return true; } [[deprecated("Don't use this version")]] [[nodiscard]] bool bar() { return true; }
ABS_Never	Never break after the last attribute of the group. [[maybe_unused]] const int i; [[gnu::const]] [[maybe_unused]] int j; [[nodiscard]] inline int f(); [[gnu::const]] [[nodiscard]] int g(); [[likely]] if (a) f(); else g(); switch (b) { [[unlikely]] case 1: ++b; break; [[likely]] default: return; }

Definition at line 1685 of file Format.h.

BinaryOperatorStyle

enum clang::format::FormatStyle::BinaryOperatorStyle : int8_t

The style of breaking before or after binary operators.

Enumerator
BOS_None	Break after operators. LooooooooooongType loooooooooooooooooooooongVariable = someLooooooooooooooooongFunction(); bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc;
BOS_NonAssignment	Break before operators that aren't assignments. LooooooooooongType loooooooooooooooooooooongVariable = someLooooooooooooooooongFunction(); bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc;
BOS_All	Break before operators. LooooooooooongType loooooooooooooooooooooongVariable = someLooooooooooooooooongFunction(); bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > ccccccccccccccccccccccccccccccccccccccccc;

Definition at line 1871 of file Format.h.

BinPackArgumentsStyle

enum clang::format::FormatStyle::BinPackArgumentsStyle : int8_t

Different ways to try to fit all arguments on a line.

Enumerator
BPAS_BinPack	Bin-pack arguments. void f() { f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); }
BPAS_OnePerLine	Put all arguments on the current line if they fit. Otherwise, put each one on its own line. void f() { f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); }
BPAS_UseBreakAfter	Use the BreakAfter option to handle argument packing instead. If the BreakAfter limit is not exceeded, behave like BinPack.

Definition at line 4223 of file Format.h.

BinPackParametersStyle

enum clang::format::FormatStyle::BinPackParametersStyle : int8_t

Different ways to try to fit all parameters on a line.

Enumerator
BPPS_BinPack	Bin-pack parameters. void f(int a, int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, int ccccccccccccccccccccccccccccccccccccccccccc);
BPPS_OnePerLine	Put all parameters on the current line if they fit. Otherwise, put each one on its own line. void f(int a, int b, int c); void f(int a, int b, int ccccccccccccccccccccccccccccccccccccc);
BPPS_AlwaysOnePerLine	Always put each parameter on its own line. void f(int a, int b, int c);
BPPS_UseBreakAfter	Use the BreakAfter option to handle parameter packing instead. If the BreakAfter limit is not exceeded, behave like BinPack.

Definition at line 4351 of file Format.h.

BinPackStyle

enum clang::format::FormatStyle::BinPackStyle : int8_t

The style of wrapping parameters on the same line (bin-packed) or on one line each.

Enumerator
BPS_Auto	Automatically determine parameter bin-packing behavior.
BPS_Always	Always bin-pack parameters.
BPS_Never	Never bin-pack parameters.

Definition at line 1861 of file Format.h.

BitFieldColonSpacingStyle

enum clang::format::FormatStyle::BitFieldColonSpacingStyle : int8_t

This option is deprecated.

See BinPack of PackParameters.

Version

3.7 Styles for adding spacing around : in bitfield definitions.

Enumerator
BFCS_Both	Add one space on each side of the : unsigned bf : 2;
BFCS_None	Add no space around the : (except when needed for AlignConsecutiveBitFields). unsigned bf:2;
BFCS_Before	Add space before the : only. unsigned bf :2;
BFCS_After	Add space after the : only (space may be added before if needed for AlignConsecutiveBitFields). unsigned bf: 2;

Definition at line 1328 of file Format.h.

BraceBreakingStyle

enum clang::format::FormatStyle::BraceBreakingStyle : int8_t

Different ways to attach braces to their surrounding context.

Enumerator
BS_Attach	Always attach braces to surrounding context. namespace N { enum E { E1, E2, }; class C { public: C(); }; bool baz(int i) { try { do { switch (i) { case 1: { foobar(); break; } default: { break; } } } while (--i); return true; } catch (...) { handleError(); return false; } } void foo(bool b) { if (b) { baz(2); } else { baz(5); } } void bar() { foo(true); } } // namespace N
BS_Linux	Like Attach, but break before braces on function, namespace and class definitions. namespace N { enum E { E1, E2, }; class C { public: C(); }; bool baz(int i) { try { do { switch (i) { case 1: { foobar(); break; } default: { break; } } } while (--i); return true; } catch (...) { handleError(); return false; } } void foo(bool b) { if (b) { baz(2); } else { baz(5); } } void bar() { foo(true); } } // namespace N
BS_Mozilla	Like Attach, but break before braces on enum, function, and record definitions. namespace N { enum E { E1, E2, }; class C { public: C(); }; bool baz(int i) { try { do { switch (i) { case 1: { foobar(); break; } default: { break; } } } while (--i); return true; } catch (...) { handleError(); return false; } } void foo(bool b) { if (b) { baz(2); } else { baz(5); } } void bar() { foo(true); } } // namespace N
BS_Stroustrup	Like Attach, but break before function definitions, catch, and else. namespace N { enum E { E1, E2, }; class C { public: C(); }; bool baz(int i) { try { do { switch (i) { case 1: { foobar(); break; } default: { break; } } } while (--i); return true; } catch (...) { handleError(); return false; } } void foo(bool b) { if (b) { baz(2); } else { baz(5); } } void bar() { foo(true); } } // namespace N
BS_Allman	Always break before braces. namespace N { enum E { E1, E2, }; class C { public: C(); }; bool baz(int i) { try { do { switch (i) { case 1: { foobar(); break; } default: { break; } } } while (--i); return true; } catch (...) { handleError(); return false; } } void foo(bool b) { if (b) { baz(2); } else { baz(5); } } void bar() { foo(true); } } // namespace N
BS_Whitesmiths	Like Allman but always indent braces and line up code with braces. namespace N { enum E { E1, E2, }; class C { public: C(); }; bool baz(int i) { try { do { switch (i) { case 1: { foobar(); break; } default: { break; } } } while (--i); return true; } catch (...) { handleError(); return false; } } void foo(bool b) { if (b) { baz(2); } else { baz(5); } } void bar() { foo(true); } } // namespace N
BS_GNU	Always break before braces and add an extra level of indentation to braces of control statements, not to those of class, function or other definitions. namespace N { enum E { E1, E2, }; class C { public: C(); }; bool baz(int i) { try { do { switch (i) { case 1: { foobar(); break; } default: { break; } } } while (--i); return true; } catch (...) { handleError(); return false; } } void foo(bool b) { if (b) { baz(2); } else { baz(5); } } void bar() { foo(true); } } // namespace N
BS_WebKit	Like Attach, but break before functions. namespace N { enum E { E1, E2, }; class C { public: C(); }; bool baz(int i) { try { do { switch (i) { case 1: { foobar(); break; } default: { break; } } } while (--i); return true; } catch (...) { handleError(); return false; } } void foo(bool b) { if (b) { baz(2); } else { baz(5); } } void bar() { foo(true); } } // namespace N
BS_Custom	Configure each individual brace in BraceWrapping.

Definition at line 1915 of file Format.h.

BracedListStyle

enum clang::format::FormatStyle::BracedListStyle : int8_t

Different ways to handle braced lists.

Enumerator
BLS_Block	Best suited for pre C++11 braced lists. Spaces inside the braced list. Line break before the closing brace. Indentation with the block indent. vector<int> x{ 1, 2, 3, 4 }; vector<T> x{ {}, {}, {}, {} }; f(MyMap[{ composite, key }]); new int[3]{ 1, 2, 3 }; Type name{ // Comment value };
BLS_FunctionCall	Best suited for C++11 braced lists. No spaces inside the braced list. No line break before the closing brace. Indentation with the continuation indent. Fundamentally, C++11 braced lists are formatted exactly like function calls would be formatted in their place. If the braced list follows a name (e.g. a type or variable name), clang-format formats as if the {} were the parentheses of a function call with that name. If there is no name, a zero-length name is assumed. vector<int> x{1, 2, 3, 4}; vector<T> x{{}, {}, {}, {}}; f(MyMap[{composite, key}]); new int[3]{1, 2, 3}; Type name{ // Comment value};
BLS_AlignFirstComment	Same as FunctionCall, except for the handling of a comment at the begin, it then aligns everything following with the comment. No spaces inside the braced list. (Even for a comment at the first position.) No line break before the closing brace. Indentation with the continuation indent, except when followed by a line comment, then it uses the block indent. vector<int> x{1, 2, 3, 4}; vector<T> x{{}, {}, {}, {}}; f(MyMap[{composite, key}]); new int[3]{1, 2, 3}; Type name{// Comment value};

Definition at line 2867 of file Format.h.

BraceWrappingAfterControlStatementStyle

enum clang::format::FormatStyle::BraceWrappingAfterControlStatementStyle : int8_t

Different ways to wrap braces after control statements.

Enumerator
BWACS_Never	Never wrap braces after a control statement. if (foo()) { } else { } for (int i = 0; i < 10; ++i) { }
BWACS_MultiLine	Only wrap braces after a multi-line control statement. if (foo && bar && baz) { quux(); } while (foo || bar) { }
BWACS_Always	Always wrap braces after a control statement. if (foo()) { } else {} for (int i = 0; i < 10; ++i) {}

Definition at line 1390 of file Format.h.

BreakBeforeConceptDeclarationsStyle

enum clang::format::FormatStyle::BreakBeforeConceptDeclarationsStyle : int8_t

Different ways to break before concept declarations.

Enumerator
BBCDS_Never	Keep the template declaration line together with concept. template <typename T> concept C = ...;
BBCDS_Allowed	Breaking between template declaration and concept is allowed. The actual behavior depends on the content and line breaking rules and penalties.
BBCDS_Always	Always break before concept, putting it in the line after the template declaration. template <typename T> concept C = ...;

Definition at line 2413 of file Format.h.

BreakBeforeInlineASMColonStyle

enum clang::format::FormatStyle::BreakBeforeInlineASMColonStyle : int8_t

Different ways to break ASM parameters.

Enumerator
BBIAS_Never	No break before inline ASM colon. asm volatile("string", : : val);
BBIAS_OnlyMultiline	Break before inline ASM colon if the line length is longer than column limit. asm volatile("string", : : val); asm("cmoveq %1, %2, %[result]" : [result] "=r"(result) : "r"(test), "r"(new), "[result]"(old));
BBIAS_Always	Always break before inline ASM colon. asm volatile("string", : : val);

Definition at line 2437 of file Format.h.

BreakBeforeNoexceptSpecifierStyle

enum clang::format::FormatStyle::BreakBeforeNoexceptSpecifierStyle : int8_t

Different ways to break before a noexcept specifier.

Enumerator
BBNSS_Never	No line break allowed. void foo(int arg1, double arg2) noexcept; void bar(int arg1, double arg2) noexcept( noexcept(baz(arg1)) && noexcept(baz(arg2)));
BBNSS_OnlyWithParen	For a simple noexcept there is no line break allowed, but when we have a condition it is. void foo(int arg1, double arg2) noexcept; void bar(int arg1, double arg2) noexcept(noexcept(baz(arg1)) && noexcept(baz(arg2)));
BBNSS_Always	Line breaks are allowed. But note that because of the associated penalties clang-format often prefers not to break before the noexcept. void foo(int arg1, double arg2) noexcept; void bar(int arg1, double arg2) noexcept(noexcept(baz(arg1)) && noexcept(baz(arg2)));

Definition at line 694 of file Format.h.

BreakBeforeReturnTypeStyle

enum clang::format::FormatStyle::BreakBeforeReturnTypeStyle : int8_t

Different ways to break before the function return type.

Enumerator
BBRTS_None	Do not force a break before the return type.
BBRTS_All	Always break before the return type. static inline void f();
BBRTS_TopLevel	Break before the return type of top-level functions only.
BBRTS_AllDefinitions	Break before the return type of function definitions only.
BBRTS_TopLevelDefinitions	Break before the return type of top-level definitions only.

Definition at line 2466 of file Format.h.

BreakBinaryOperationsStyle

enum clang::format::FormatStyle::BreakBinaryOperationsStyle : int8_t

Different ways to break binary operations.

Enumerator
BBO_Never	Don't break binary operations. aaa + bbbb * ccccc - ddddd + eeeeeeeeeeeeeeee;
BBO_OnePerLine	Binary operations will either be all on the same line, or each operation will have one line each. aaa + bbbb * ccccc - ddddd + eeeeeeeeeeeeeeee;
BBO_RespectPrecedence	Binary operations of a particular precedence that exceed the column limit will have one line each. aaa + bbbb * ccccc - ddddd + eeeeeeeeeeeeeeee;

Definition at line 2533 of file Format.h.

BreakConstructorInitializersStyle

enum clang::format::FormatStyle::BreakConstructorInitializersStyle : int8_t

Different ways to break initializers.

Enumerator
BCIS_BeforeColon	Break constructor initializers before the colon and after the commas. Constructor() : initializer1(), initializer2()
BCIS_BeforeComma	Break constructor initializers before the colon and commas, and align the commas with the colon. Constructor() : initializer1() , initializer2()
BCIS_AfterColon	Break constructor initializers after the colon and commas. Constructor() : initializer1(), initializer2()
BCIS_AfterComma	Break constructor initializers only after the commas. Constructor() : initializer1(), initializer2()

Definition at line 2643 of file Format.h.

BreakInheritanceListStyle

enum clang::format::FormatStyle::BreakInheritanceListStyle : int8_t

Different ways to break inheritance list.

Enumerator
BILS_BeforeColon	Break inheritance list before the colon and after the commas. class Foo : Base1, Base2 {};
BILS_BeforeComma	Break inheritance list before the colon and commas, and align the commas with the colon. class Foo : Base1 , Base2 {};
BILS_AfterColon	Break inheritance list after the colon and commas. class Foo : Base1, Base2 {};
BILS_AfterComma	Break inheritance list only after the commas. class Foo : Base1, Base2 {};

Definition at line 2778 of file Format.h.

BreakTemplateDeclarationsStyle

enum clang::format::FormatStyle::BreakTemplateDeclarationsStyle : int8_t

Different ways to break after the template declaration.

Enumerator
BTDS_Leave	Do not change the line breaking before the declaration. template <typename T> T foo() { } template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbbbbbbbbbb) { }
BTDS_No	Do not force break before declaration. PenaltyBreakTemplateDeclaration is taken into account. template <typename T> T foo() { } template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbbbbbbbbbb) { }
BTDS_MultiLine	Force break after template declaration only when the following declaration spans multiple lines. template <typename T> T foo() { } template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbbbbbbbbbb) { }
BTDS_Yes	Always break after template declaration. template <typename T> T foo() { } template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbbbbbbbbbb) { }

Definition at line 1234 of file Format.h.

DAGArgStyle

enum clang::format::FormatStyle::DAGArgStyle : int8_t

Different ways to control the format inside TableGen DAGArg.

Enumerator
DAS_DontBreak	Never break inside DAGArg. let DAGArgIns = (ins i32:$src1, i32:$src2);
DAS_BreakElements	Break inside DAGArg after each list element but for the last. This aligns to the first element. let DAGArgIns = (ins i32:$src1, i32:$src2);
DAS_BreakAll	Break inside DAGArg after the operator and the all elements. let DAGArgIns = (ins i32:$src1, i32:$src2 );

Definition at line 5914 of file Format.h.

DefinitionReturnTypeBreakingStyle

enum clang::format::FormatStyle::DefinitionReturnTypeBreakingStyle : int8_t

Different ways to break after the function definition return type.

This option is deprecated and is retained for backwards compatibility.

Enumerator
DRTBS_None	Break after return type automatically. PenaltyReturnTypeOnItsOwnLine is taken into account.
DRTBS_All	Always break after the return type.
DRTBS_TopLevel	Always break after the return types of top-level functions.

Definition at line 1104 of file Format.h.

EmptyLineAfterAccessModifierStyle

enum clang::format::FormatStyle::EmptyLineAfterAccessModifierStyle : int8_t

Different styles for empty line after access modifiers.

EmptyLineBeforeAccessModifier configuration handles the number of empty lines between two access modifiers.

Enumerator
ELAAMS_Never	Remove all empty lines after access modifiers. struct foo { private: int i; protected: int j; /* comment */ public: foo() {} private: protected: };
ELAAMS_Leave	Keep existing empty lines after access modifiers. MaxEmptyLinesToKeep is applied instead.
ELAAMS_Always	Always add empty line after access modifiers if there are none. MaxEmptyLinesToKeep is applied also. struct foo { private: int i; protected: int j; /* comment */ public: foo() {} private: protected: };

Definition at line 2948 of file Format.h.

EmptyLineBeforeAccessModifierStyle

enum clang::format::FormatStyle::EmptyLineBeforeAccessModifierStyle : int8_t

Different styles for empty line before access modifiers.

Enumerator
ELBAMS_Never	Remove all empty lines before access modifiers. struct foo { private: int i; protected: int j; /* comment */ public: foo() {} private: protected: };
ELBAMS_Leave	Keep existing empty lines before access modifiers.
ELBAMS_LogicalBlock	Add empty line only when access modifier starts a new logical block. Logical block is a group of one or more member fields or functions. struct foo { private: int i; protected: int j; /* comment */ public: foo() {} private: protected: };
ELBAMS_Always	Always add empty line before access modifiers unless access modifier is at the start of struct or class definition. struct foo { private: int i; protected: int j; /* comment */ public: foo() {} private: protected: };

Definition at line 2997 of file Format.h.

EnumTrailingCommaStyle

enum clang::format::FormatStyle::EnumTrailingCommaStyle : int8_t

Styles for enum trailing commas.

Enumerator
ETC_Leave	Don't insert or remove trailing commas. enum { a, b, c, }; enum Color { red, green, blue };
ETC_Insert	Insert trailing commas. enum { a, b, c, }; enum Color { red, green, blue, };
ETC_Remove	Remove trailing commas. enum { a, b, c }; enum Color { red, green, blue };

Definition at line 3060 of file Format.h.

EscapedNewlineAlignmentStyle

enum clang::format::FormatStyle::EscapedNewlineAlignmentStyle : int8_t

Different styles for aligning escaped newlines.

Enumerator
ENAS_DontAlign	Don't align escaped newlines. #define A \ int aaaa; \ int b; \ int dddddddddd;
ENAS_Left	Align escaped newlines as far left as possible. #define A \ int aaaa; \ int b; \ int dddddddddd;
ENAS_LeftWithLastLine	Align escaped newlines as far left as possible, using the last line of the preprocessor directive as the reference if it's the longest. #define A \ int aaaa; \ int b; \ int dddddddddd;
ENAS_Right	Align escaped newlines in the right-most column. #define A \ int aaaa; \ int b; \ int dddddddddd;

Definition at line 477 of file Format.h.

IndentExternBlockStyle

enum clang::format::FormatStyle::IndentExternBlockStyle : int8_t

Indents extern blocks.

Enumerator
IEBS_AfterExternBlock	Backwards compatible with AfterExternBlock's indenting. IndentExternBlock: AfterExternBlock BraceWrapping.AfterExternBlock: true extern "C" { void foo(); } IndentExternBlock: AfterExternBlock BraceWrapping.AfterExternBlock: false extern "C" { void foo(); }
IEBS_NoIndent	Does not indent extern blocks. extern "C" { void foo(); }
IEBS_Indent	Indents extern blocks. extern "C" { void foo(); }

Definition at line 3247 of file Format.h.

IndentGotoLabelStyle

enum clang::format::FormatStyle::IndentGotoLabelStyle : int8_t

Options for indenting goto labels.

Enumerator
IGLS_NoIndent	Do not indent goto labels. int f() { if (foo()) { label1: bar(); } label2: return 1; }
IGLS_OuterIndent	Indent goto labels to the enclosing block (previous indenting level). int f() { if (foo()) { label1: bar(); } label2: return 1; }
IGLS_InnerIndent	Indent goto labels to the surrounding statements (current indenting level). int f() { if (foo()) { label1: bar(); } label2: return 1; }
IGLS_HalfIndent	Indent goto labels to half the indentation of the surrounding code. If the indentation width is an odd number, it will round up. int f() { if (foo()) { label1: bar(); } label2: return 1; }

Definition at line 3287 of file Format.h.

JavaScriptQuoteStyle

enum clang::format::FormatStyle::JavaScriptQuoteStyle : int8_t

Quotation styles for JavaScript strings.

Does not affect template strings.

Enumerator
JSQS_Leave	Leave string quotes as they are. string1 = "foo"; string2 = 'bar';
JSQS_Single	Always use single quotes. string1 = 'foo'; string2 = 'bar';
JSQS_Double	Always use double quotes. string1 = "foo"; string2 = "bar";

Definition at line 3679 of file Format.h.

LambdaBodyIndentationKind

enum clang::format::FormatStyle::LambdaBodyIndentationKind : int8_t

Indentation logic for lambda bodies.

Enumerator
LBI_Signature	Align lambda body relative to the lambda signature. This is the default. someMethod( [](SomeReallyLongLambdaSignatureArgument foo) { return; });
LBI_OuterScope	For statements within block scope, align lambda body relative to the indentation level of the outer scope the lambda signature resides in. someMethod( [](SomeReallyLongLambdaSignatureArgument foo) { return; }); someMethod(someOtherMethod( [](SomeReallyLongLambdaSignatureArgument foo) { return; }));

Definition at line 3775 of file Format.h.

LanguageKind

enum clang::format::FormatStyle::LanguageKind : int8_t

Supported languages.

When stored in a configuration file, specifies the language, that the configuration targets. When passed to the reformat() function, enables syntax features specific to the language.

Enumerator
LK_None	Do not use.
LK_C	Should be used for C.
LK_Cpp	Should be used for C++.
LK_CSharp	Should be used for C#.
LK_Java	Should be used for Java.
LK_JavaScript	Should be used for JavaScript.
LK_Json	Should be used for JSON.
LK_ObjC	Should be used for Objective-C, Objective-C++.
LK_Proto	Should be used for Protocol Buffers
LK_TableGen	Should be used for TableGen code.
LK_TextProto	Should be used for Protocol Buffer messages in text format.
LK_Verilog	Should be used for Verilog and SystemVerilog. https://standards.ieee.org/ieee/1800/6700/ https://sci-hub.st/10.1109/IEEESTD.2018.8299595

Definition at line 3813 of file Format.h.

LanguageStandard

enum clang::format::FormatStyle::LanguageStandard : int8_t

Supported language standards for parsing and formatting C++ constructs.

Latest:                                vector<set<int>>
c++03                          vs.     vector<set<int> >

The correct way to spell a specific language version is e.g. c++11. The historical aliases Cpp03 and Cpp11 are deprecated.

Enumerator
LS_Cpp03	Parse and format as C++03. Cpp03 is a deprecated alias for c++03
LS_Cpp11	Parse and format as C++11.
LS_Cpp14	Parse and format as C++14.
LS_Cpp17	Parse and format as C++17.
LS_Cpp20	Parse and format as C++20.
LS_Cpp23	Parse and format as C++23.
LS_Cpp26	Parse and format as C++26.
LS_Latest	Parse and format using the latest supported language version. Cpp11 is a deprecated alias for Latest
LS_Auto	Automatic detection based on the input.

Definition at line 5829 of file Format.h.

LineEndingStyle

enum clang::format::FormatStyle::LineEndingStyle : int8_t

Line ending style.

Enumerator
LE_LF	Use \n.
LE_CRLF	Use \r\n.
LE_DeriveLF	Use \n unless the input has more lines ending in \r\n.
LE_DeriveCRLF	Use \r\n unless the input has more lines ending in \n.

Definition at line 3864 of file Format.h.

NamespaceIndentationKind

enum clang::format::FormatStyle::NamespaceIndentationKind : int8_t

Different ways to indent namespace contents.

Enumerator
NI_None	Don't indent in namespaces. namespace out { int i; namespace in { int i; } }
NI_Inner	Indent only in inner namespaces (nested in other namespaces). namespace out { int i; namespace in { int i; } }
NI_All	Indent in all namespaces. namespace out { int i; namespace in { int i; } }

Definition at line 3969 of file Format.h.

NumericLiteralComponentStyle

enum clang::format::FormatStyle::NumericLiteralComponentStyle : int8_t

Control over each component in a numeric literal.

Enumerator
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.

Definition at line 4020 of file Format.h.

OperandAlignmentStyle

enum clang::format::FormatStyle::OperandAlignmentStyle : int8_t

Different styles for aligning operands.

Enumerator
OAS_DontAlign	Do not align operands of binary and ternary expressions. The wrapped lines are indented ContinuationIndentWidth spaces from the start of the line.
OAS_Align	Horizontally align operands of binary and ternary expressions. Specifically, this aligns operands of a single expression that needs to be split over multiple lines, e.g.: int aaa = bbbbbbbbbbbbbbb + ccccccccccccccc; When BreakBeforeBinaryOperators is set, the wrapped operator is aligned with the operand on the first line. int aaa = bbbbbbbbbbbbbbb + ccccccccccccccc;
OAS_AlignAfterOperator	Horizontally align operands of binary and ternary expressions. This is similar to OAS_Align, except when BreakBeforeBinaryOperators is set, the operator is un-indented so that the wrapped operand is aligned with the operand on the first line. int aaa = bbbbbbbbbbbbbbb + ccccccccccccccc;

Definition at line 518 of file Format.h.

PackConstructorInitializersStyle

enum clang::format::FormatStyle::PackConstructorInitializersStyle : int8_t

Different ways to try to fit all constructor initializers on a line.

Enumerator
PCIS_Never	Always put each constructor initializer on its own line. Constructor() : a(), b()
PCIS_BinPack	Bin-pack constructor initializers. Constructor() : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), cccccccccccccccccccc()
PCIS_CurrentLine	Put all constructor initializers on the current line if they fit. Otherwise, put each one on its own line. Constructor() : a(), b() Constructor() : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), ddddddddddddd()
PCIS_NextLine	Same as PCIS_CurrentLine except that if all constructor initializers do not fit on the current line, try to fit them on the next line. Constructor() : a(), b() Constructor() : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), ddddddddddddd() Constructor() : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), cccccccccccccccccccc()
PCIS_NextLineOnly	Put all constructor initializers on the next line if they fit. Otherwise, put each one on its own line. Constructor() : a(), b() Constructor() : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), ddddddddddddd() Constructor() : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), cccccccccccccccccccc()

Definition at line 4289 of file Format.h.

PointerAlignmentStyle

enum clang::format::FormatStyle::PointerAlignmentStyle : int8_t

The &, && and * alignment style.

Enumerator
PAS_Left	Align pointer to the left. int* a;
PAS_Right	Align pointer to the right. int *a;
PAS_Middle	Align pointer in the middle. int * a;

Definition at line 4471 of file Format.h.

PPDirectiveIndentStyle

enum clang::format::FormatStyle::PPDirectiveIndentStyle : int8_t

Options for indenting preprocessor directives.

Enumerator
PPDIS_None	Does not indent any directives. #if FOO #if BAR #include <foo> #endif #endif
PPDIS_AfterHash	Indents directives after the hash. #if FOO # if BAR # include <foo> # endif #endif
PPDIS_BeforeHash	Indents directives before the hash. #if FOO #if BAR #include <foo> #endif #endif
PPDIS_Leave	Leaves indentation of directives as-is. Note Ignores PPIndentWidth. \endnote #if FOO #if BAR #include <foo> #endif #endif

Definition at line 3345 of file Format.h.

QualifierAlignmentStyle

enum clang::format::FormatStyle::QualifierAlignmentStyle : int8_t

Different specifiers and qualifiers alignment styles.

Enumerator
QAS_Leave	Don't change specifiers/qualifiers to either Left or Right alignment (default). int const a; const int *a;
QAS_Left	Change specifiers/qualifiers to be left-aligned. const int a; const int *a;
QAS_Right	Change specifiers/qualifiers to be right-aligned. int const a; int const *a;
QAS_Custom	Change specifiers/qualifiers to be aligned based on QualifierOrder. With: QualifierOrder: [inline, static, type, const] int const a; int const *a;

Definition at line 4509 of file Format.h.

ReferenceAlignmentStyle

enum clang::format::FormatStyle::ReferenceAlignmentStyle : int8_t

The & and && alignment style.

Enumerator
RAS_Pointer	Align reference like PointerAlignment.
RAS_Left	Align reference to the left. int& a;
RAS_Right	Align reference to the right. int &a;
RAS_Middle	Align reference in the middle. int & a;

Definition at line 4641 of file Format.h.

ReflowCommentsStyle

enum clang::format::FormatStyle::ReflowCommentsStyle : int8_t

Types of comment reflow style.

Enumerator
RCS_Never	Leave comments untouched. // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */ /* third veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information * and a misaligned second line */
RCS_IndentOnly	Only apply indentation rules, moving comments left or right, without changing formatting inside the comments. // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */ /* third veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information * and a misaligned second line */
RCS_Always	Apply indentation rules and reflow long comments into new lines, trying to obey the ColumnLimit. // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of // information /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of * information */ /* third veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of * information and a misaligned second line */

Definition at line 4667 of file Format.h.

RemoveParenthesesStyle

enum clang::format::FormatStyle::RemoveParenthesesStyle : int8_t

Types of redundant parentheses to remove.

Enumerator
RPS_Leave	Do not remove parentheses. class __declspec((dllimport)) X {}; co_return (((0))); return ((a + b) - ((c + d)));
RPS_MultipleParentheses	Replace multiple parentheses with single parentheses. class __declspec(dllimport) X {}; co_return (0); return ((a + b) - (c + d));
RPS_ReturnStatement	Also remove parentheses enclosing the expression in a return/co_return statement. class __declspec(dllimport) X {}; co_return 0; return (a + b) - (c + d);

Definition at line 4781 of file Format.h.

RequiresClausePositionStyle

enum clang::format::FormatStyle::RequiresClausePositionStyle : int8_t

The possible positions for the requires clause.

The IndentRequires option is only used if the requires is put on the start of a line.

Enumerator
RCPS_OwnLine	Always put the requires clause on its own line (possibly followed by a semicolon). template <typename T> requires C<T> struct Foo {... template <typename T> void bar(T t) requires C<T>; template <typename T> requires C<T> void bar(T t) {... template <typename T> void baz(T t) requires C<T> {...
RCPS_OwnLineWithBrace	As with OwnLine, except, unless otherwise prohibited, place a following open brace (of a function definition) to follow on the same line. void bar(T t) requires C<T> { return; } void bar(T t) requires C<T> {} template <typename T> requires C<T> void baz(T t) { ...
RCPS_WithPreceding	Try to put the clause together with the preceding part of a declaration. For class templates: stick to the template declaration. For function templates: stick to the template declaration. For function declaration followed by a requires clause: stick to the parameter list. template <typename T> requires C<T> struct Foo {... template <typename T> requires C<T> void bar(T t) {... template <typename T> void baz(T t) requires C<T> {...
RCPS_WithFollowing	Try to put the requires clause together with the class or function declaration. template <typename T> requires C<T> struct Foo {... template <typename T> requires C<T> void bar(T t) {... template <typename T> void baz(T t) requires C<T> {...
RCPS_SingleLine	Try to put everything in the same line if possible. Otherwise normal line breaking rules take over. // Fitting: template <typename T> requires C<T> struct Foo {... template <typename T> requires C<T> void bar(T t) {... template <typename T> void bar(T t) requires C<T> {... // Not fitting, one possible example: template <typename LongName> requires C<LongName> struct Foo {... template <typename LongName> requires C<LongName> void bar(LongName ln) { template <typename LongName> void bar(LongName ln) requires C<LongName> {

Definition at line 4836 of file Format.h.

RequiresExpressionIndentationKind

enum clang::format::FormatStyle::RequiresExpressionIndentationKind : int8_t

Indentation logic for requires expression bodies.

Enumerator
REI_OuterScope	Align requires expression body relative to the indentation level of the outer scope the requires expression resides in. This is the default. template <typename T> concept C = requires(T t) { ... }
REI_Keyword	Align requires expression body relative to the requires keyword. template <typename T> concept C = requires(T t) { ... }

Definition at line 4938 of file Format.h.

ReturnTypeBreakingStyle

enum clang::format::FormatStyle::ReturnTypeBreakingStyle : int8_t

Different ways to break after the function definition or declaration return type.

Enumerator
RTBS_None	This is deprecated. See Automatic below.
RTBS_Automatic	Break after return type based on PenaltyReturnTypeOnItsOwnLine. class A { int f() { return 0; }; }; int f(); int f() { return 1; } int LongName::AnotherLongName();
RTBS_ExceptShortType	Same as Automatic above, except that there is no break after short return types. class A { int f() { return 0; }; }; int f(); int f() { return 1; } int LongName:: AnotherLongName();
RTBS_All	Always break after the return type. class A { int f() { return 0; }; }; int f(); int f() { return 1; } int LongName::AnotherLongName();
RTBS_TopLevel	Always break after the return types of top-level functions. class A { int f() { return 0; }; }; int f(); int f() { return 1; } int LongName::AnotherLongName();
RTBS_AllDefinitions	Always break after the return type of function definitions. class A { int f() { return 0; }; }; int f(); int f() { return 1; } int LongName::AnotherLongName();
RTBS_TopLevelDefinitions	Always break after the return type of top-level definitions. class A { int f() { return 0; }; }; int f(); int f() { return 1; } int LongName::AnotherLongName();

Definition at line 1116 of file Format.h.

SeparateDefinitionStyle

enum clang::format::FormatStyle::SeparateDefinitionStyle : int8_t

The style if definition blocks should be separated.

Enumerator
SDS_Leave	Leave definition blocks as they are.
SDS_Always	Insert an empty line between definition blocks.
SDS_Never	Remove any empty line between definition blocks.

Definition at line 4964 of file Format.h.

ShortBlockStyle

enum clang::format::FormatStyle::ShortBlockStyle : int8_t

Different styles for merging short blocks containing at most one statement.

Enumerator
SBS_Never	Never merge blocks into a single line. while (true) { } while (true) { continue; }
SBS_Empty	Only merge empty blocks. while (true) {} while (true) { continue; }
SBS_Always	Always merge short blocks into a single line. while (true) {} while (true) { continue; }

Definition at line 742 of file Format.h.

ShortIfStyle

enum clang::format::FormatStyle::ShortIfStyle : int8_t

Different styles for handling short if statements.

Enumerator
SIS_Never	Never put short ifs on the same line. if (a) return; if (b) return; else return; if (c) return; else { return; }
SIS_WithoutElse	Put short ifs on the same line only if there is no else statement. if (a) return; if (b) return; else return; if (c) return; else { return; }
SIS_OnlyFirstIf	Put short ifs, but not else ifs nor else statements, on the same line. if (a) return; if (b) return; else if (b) return; else return; if (c) return; else { return; }
SIS_AllIfsAndElse	Always put short ifs, else ifs and else statements on the same line. if (a) return; if (b) return; else return; if (c) return; else { return; }

Definition at line 959 of file Format.h.

ShortLambdaStyle

enum clang::format::FormatStyle::ShortLambdaStyle : int8_t

Different styles for merging short lambdas containing at most one statement.

Enumerator
SLS_None	Never merge lambdas into a single line.
SLS_Empty	Only merge empty lambdas. auto lambda = [](int a) {}; auto lambda2 = [](int a) { return a; };
SLS_Inline	Merge lambda into a single line if the lambda is argument of a function. auto lambda = [](int x, int y) { return x < y; }; sort(a.begin(), a.end(), [](int x, int y) { return x < y; });
SLS_All	Merge all lambdas fitting on a single line. auto lambda = [](int a) {}; auto lambda2 = [](int a) { return a; };

Definition at line 1031 of file Format.h.

ShortRecordStyle

enum clang::format::FormatStyle::ShortRecordStyle : int8_t

Different styles for merging short records (class,struct, and union).

Enumerator
SRS_Never	Never merge records into a single line.
SRS_EmptyAndAttached	Only merge empty records if the opening brace was not wrapped, i.e. the corresponding BraceWrapping.After... option was not set.
SRS_Empty	Only merge empty records. struct foo {}; struct bar { int i; };
SRS_Always	Merge all records that fit on a single line. struct foo {}; struct bar { int i; };

Definition at line 1074 of file Format.h.

SortJavaStaticImportOptions

enum clang::format::FormatStyle::SortJavaStaticImportOptions : int8_t

Position for Java Static imports.

Enumerator
SJSIO_Before	Static imports are placed before non-static imports. import static org.example.function1; import org.example.ClassA;
SJSIO_After	Static imports are placed after non-static imports. import org.example.ClassA; import static org.example.function1;

Definition at line 5096 of file Format.h.

SortUsingDeclarationsOptions

enum clang::format::FormatStyle::SortUsingDeclarationsOptions : int8_t

Using declaration sorting options.

Enumerator
SUD_Never	Using declarations are never sorted. using std::chrono::duration_cast; using std::move; using boost::regex; using boost::regex_constants::icase; using std::string;
SUD_Lexicographic	Using declarations are sorted in the order defined as follows: Split the strings by :: and discard any initial empty strings. Sort the lists of names lexicographically, and within those groups, names are in case-insensitive lexicographic order. using boost::regex; using boost::regex_constants::icase; using std::chrono::duration_cast; using std::move; using std::string;
SUD_LexicographicNumeric	Using declarations are sorted in the order defined as follows: Split the strings by :: and discard any initial empty strings. The last element of each list is a non-namespace name; all others are namespace names. Sort the lists of names lexicographically, where the sort order of individual names is that all non-namespace names come before all namespace names, and within those groups, names are in case-insensitive lexicographic order. using boost::regex; using boost::regex_constants::icase; using std::move; using std::string; using std::chrono::duration_cast;

Definition at line 5120 of file Format.h.

SpaceAroundPointerQualifiersStyle

enum clang::format::FormatStyle::SpaceAroundPointerQualifiersStyle : int8_t

Different ways to put a space before opening parentheses.

Enumerator
SAPQ_Default	Don't ensure spaces around pointer qualifiers and use PointerAlignment instead. PointerAlignment: Left PointerAlignment: Right void* const* x = NULL; vs. void *const *x = NULL;
SAPQ_Before	Ensure that there is a space before pointer qualifiers. PointerAlignment: Left PointerAlignment: Right void* const* x = NULL; vs. void * const *x = NULL;
SAPQ_After	Ensure that there is a space after pointer qualifiers. PointerAlignment: Left PointerAlignment: Right void* const * x = NULL; vs. void *const *x = NULL;
SAPQ_Both	Ensure that there is a space both before and after pointer qualifiers. PointerAlignment: Left PointerAlignment: Right void* const * x = NULL; vs. void * const *x = NULL;

Definition at line 5196 of file Format.h.

SpaceBeforeParensStyle

enum clang::format::FormatStyle::SpaceBeforeParensStyle : int8_t

Different ways to put a space before opening parentheses.

Enumerator
SBPO_Never	This is deprecated and replaced by Custom below, with all SpaceBeforeParensOptions but AfterPlacementOperator set to false.
SBPO_ControlStatements	Put a space before opening parentheses only after control statement keywords (for/if/while...). void f() { if (true) { f(); } }
SBPO_ControlStatementsExceptControlMacros	Same as SBPO_ControlStatements except this option doesn't apply to ForEach and If macros. This is useful in projects where ForEach/If macros are treated as function calls instead of control statements. SBPO_ControlStatementsExceptForEachMacros remains an alias for backward compatibility. void f() { Q_FOREACH(...) { f(); } }
SBPO_NonEmptyParentheses	Put a space before opening parentheses only if the parentheses are not empty. void() { if (true) { f(); g (x, y, z); } }
SBPO_Always	Always put a space before opening parentheses, except when it's prohibited by the syntax rules (in function-like macro definitions) or when determined by other style rules (after unary operators, opening parentheses, etc.) void f () { if (true) { f (); } }
SBPO_Custom	Configure each individual space before parentheses in SpaceBeforeParensOptions.

Definition at line 5296 of file Format.h.

SpaceInEmptyBracesStyle

enum clang::format::FormatStyle::SpaceInEmptyBracesStyle : int8_t

This option is deprecated.

See Block of SpaceInEmptyBraces.

Version

10 Style of when to insert a space in empty braces.

Enumerator
SIEB_Always	Always insert a space in empty braces. void f() { } class Unit { }; auto a = [] { }; int x{ };
SIEB_Block	Only insert a space in empty blocks. void f() { } class Unit { }; auto a = [] { }; int x{};
SIEB_Never	Never insert a space in empty braces. void f() {} class Unit {}; auto a = [] {}; int x{};

Definition at line 5514 of file Format.h.

SpacesInAnglesStyle

enum clang::format::FormatStyle::SpacesInAnglesStyle : int8_t

Styles for adding spacing after < and before > in template argument lists.

Enumerator
SIAS_Never	Remove spaces after < and before >. static_cast<int>(arg); std::function<void(int)> fct;
SIAS_Always	Add spaces after < and before >. static_cast< int >(arg); std::function< void(int) > fct;
SIAS_Leave	Keep a single space after < and before > if any spaces were present. Option Standard: Cpp03 takes precedence.

Definition at line 5577 of file Format.h.

SpacesInBlockCommentsStyle

enum clang::format::FormatStyle::SpacesInBlockCommentsStyle : int8_t

Styles for controlling spacing after /* and before `.

Enumerator
SIBCS_Never	Remove spaces after /* and before `.
SIBCS_Always	Add spaces after /* and before `.
SIBCS_Leave	Leave existing spaces unchanged.

Definition at line 5600 of file Format.h.

SpacesInParensStyle

enum clang::format::FormatStyle::SpacesInParensStyle : int8_t

Different ways to put a space before opening and closing parentheses.

Enumerator
SIPO_Never	Never put a space in parentheses. void f() { if(true) { f(); } }
SIPO_Custom	Configure each individual space in parentheses in SpacesInParensOptions.

Definition at line 5689 of file Format.h.

TrailingCommaStyle

enum clang::format::FormatStyle::TrailingCommaStyle : int8_t

The style of inserting trailing commas into container literals.

Enumerator
TCS_None	Do not insert trailing commas.
TCS_Wrapped	Insert trailing commas in container literals that were wrapped over multiple lines. Note that this is conceptually incompatible with bin-packing, because the trailing comma is used as an indicator that a container should be formatted one-per-line (i.e. not bin-packed). So inserting a trailing comma counteracts bin-packing.

Definition at line 3479 of file Format.h.

TrailingCommentsAlignmentKinds

enum clang::format::FormatStyle::TrailingCommentsAlignmentKinds : int8_t

Enums for AlignTrailingComments.

Enumerator
TCAS_Leave	Leave trailing comments as they are. int a; // comment int ab; // comment int abc; // comment int abcd; // comment
TCAS_Always	Align trailing comments. int a; // comment int ab; // comment int abc; // comment int abcd; // comment
TCAS_Never	Don't align trailing comments but other formatter applies. int a; // comment int ab; // comment int abc; // comment int abcd; // comment

Definition at line 557 of file Format.h.

UseTabStyle

enum clang::format::FormatStyle::UseTabStyle : int8_t

This option is deprecated.

See LF and CRLF of LineEnding.

Version

10 Different ways to use tab in formatting.

Enumerator
UT_Never	Never use tab.
UT_ForIndentation	Use tabs only for indentation.
UT_ForContinuationAndIndentation	Fill all leading whitespace with tabs, and use spaces for alignment that appears within a line (e.g. consecutive assignments and declarations).
UT_AlignWithSpaces	Use tabs for line continuation and indentation, and spaces for alignment.
UT_Always	Use tabs whenever we need to fill whitespace that spans at least from one tab stop to the next one.

Definition at line 5986 of file Format.h.

WrapNamespaceBodyWithEmptyLinesStyle

enum clang::format::FormatStyle::WrapNamespaceBodyWithEmptyLinesStyle : int8_t

Different styles for wrapping namespace body with empty lines.

Enumerator
WNBWELS_Never	Remove all empty lines at the beginning and the end of namespace body. namespace N1 { namespace N2 { function(); } }
WNBWELS_Always	Always have at least one empty line at the beginning and the end of namespace body except that the number of empty lines between consecutive nested namespace definitions is not increased. namespace N1 { namespace N2 { function(); } }
WNBWELS_Leave	Keep existing newlines at the beginning and the end of namespace body. MaxEmptyLinesToKeep still applies.

Definition at line 6047 of file Format.h.

Member Function Documentation

BuildStyleSetFromConfiguration()

FormatStyleSet clang::format::FormatStyle::BuildStyleSetFromConfiguration ( const FormatStyle & MainStyle, const std::vector< FormatStyle > & ConfigurationStyles )

static

GetLanguageStyle()

std::optional< FormatStyle > clang::format::FormatStyle::GetLanguageStyle

(

FormatStyle::LanguageKind

Language

)

const

Definition at line 2629 of file Format.cpp.

isCpp()

bool clang::format::FormatStyle::isCpp ( ) const

inline

Definition at line 3842 of file Format.h.

isCSharp()

bool clang::format::FormatStyle::isCSharp ( ) const

inline

Definition at line 3845 of file Format.h.

isJava()

bool clang::format::FormatStyle::isJava ( ) const

inline

Definition at line 3847 of file Format.h.

isJavaScript()

bool clang::format::FormatStyle::isJavaScript ( ) const

inline

Definition at line 3848 of file Format.h.

isJson()

bool clang::format::FormatStyle::isJson ( ) const

inline

Definition at line 3846 of file Format.h.

isProto()

bool clang::format::FormatStyle::isProto ( ) const

inline

Definition at line 3851 of file Format.h.

isTableGen()

bool clang::format::FormatStyle::isTableGen ( ) const

inline

Definition at line 3852 of file Format.h.

isTextProto()

bool clang::format::FormatStyle::isTextProto ( ) const

inline

Definition at line 3850 of file Format.h.

isVerilog()

bool clang::format::FormatStyle::isVerilog ( ) const

inline

Definition at line 3849 of file Format.h.

operator==()

bool clang::format::FormatStyle::operator== ( const FormatStyle & R ) const

inline

Definition at line 6079 of file Format.h.

Friends And Related Symbol Documentation

parseConfiguration

std::error_code parseConfiguration ( llvm::MemoryBufferRef Config, FormatStyle * Style, bool AllowUnknownOptions = false, llvm::SourceMgr::DiagHandlerTy DiagHandler = nullptr, void * DiagHandlerCtxt = nullptr, bool IsDotHFile = false )

friend

Parse configuration from YAML-formatted text.

Style->Language is used to get the base style, if the BasedOnStyle option is present.

The FormatStyleSet of Style is reset.

When BasedOnStyle is not present, options not present in the YAML document, are retained in Style.

If AllowUnknownOptions is true, no errors are emitted if unknown format options are occurred.

If set all diagnostics are emitted through the DiagHandler.

Definition at line 2491 of file Format.cpp.

Member Data Documentation

AccessModifierOffset

int clang::format::FormatStyle::AccessModifierOffset

The extra indent or outdent of access modifiers, e.g.

public:.

Version

3.3

Definition at line 64 of file Format.h.

AlignAfterOpenBracket

bool clang::format::FormatStyle::AlignAfterOpenBracket

If true, horizontally aligns arguments after an open bracket.

true:                         vs.   false
someLongFunction(argument1,         someLongFunction(argument1,
                 argument2);            argument2);

Note

As of clang-format 22 this option is a bool with the previous option of Align replaced with true, DontAlign replaced with false, and the options of AlwaysBreak and BlockIndent replaced with true and with setting of new style options using BreakAfterOpenBracketBracedList, BreakAfterOpenBracketFunction, BreakAfterOpenBracketIf, BreakBeforeCloseBracketBracedList, BreakBeforeCloseBracketFunction, and BreakBeforeCloseBracketIf. \endnote

This applies to round brackets (parentheses), angle brackets and square brackets.

Version

3.8

Definition at line 87 of file Format.h.

AlignArrayOfStructures

ArrayInitializerAlignmentStyle clang::format::FormatStyle::AlignArrayOfStructures

If not None, when using initialization for an array of structs aligns the fields into columns.

Note

As of clang-format 15 this option only applied to arrays with equal number of columns per row. \endnote

Version

13

Definition at line 123 of file Format.h.

AlignConsecutiveAssignments

AlignConsecutiveStyle clang::format::FormatStyle::AlignConsecutiveAssignments

Style of aligning consecutive assignments.

Consecutive will result in formattings like:

int a            = 1;
int somelongname = 2;
double c         = 3;

Version

3.8

Definition at line 286 of file Format.h.

AlignConsecutiveBitFields

AlignConsecutiveStyle clang::format::FormatStyle::AlignConsecutiveBitFields

Style of aligning consecutive bit fields.

Consecutive will align the bitfield separators of consecutive lines. This will result in formattings like:

int aaaa : 1;
int b    : 12;
int ccc  : 8;

Version

11

Definition at line 298 of file Format.h.

AlignConsecutiveDeclarations

AlignConsecutiveStyle clang::format::FormatStyle::AlignConsecutiveDeclarations

Style of aligning consecutive declarations.

Consecutive will align the declaration names of consecutive lines. This will result in formattings like:

int         aaaa = 12;
float       b = 23;
std::string ccc;

Version

3.8

Definition at line 310 of file Format.h.

AlignConsecutiveMacros

AlignConsecutiveStyle clang::format::FormatStyle::AlignConsecutiveMacros

Style of aligning consecutive macro definitions.

Consecutive will result in formattings like:

#define SHORT_NAME       42
#define LONGER_NAME      0x007f
#define EVEN_LONGER_NAME (2)
#define foo(x)           (x * x)
#define bar(y, z)        (y + z)

Version

9

Definition at line 323 of file Format.h.

AlignConsecutiveShortCaseStatements

ShortCaseStatementsAlignmentStyle clang::format::FormatStyle::AlignConsecutiveShortCaseStatements

Style of aligning consecutive short case labels.

Only applies if AllowShortCaseExpressionOnASingleLine or AllowShortCaseLabelsOnASingleLine is true.

# Example of usage:
AlignConsecutiveShortCaseStatements:
  Enabled: true
  AcrossEmptyLines: true
  AcrossComments: true
  AlignCaseColons: false

Version

17

Definition at line 439 of file Format.h.

AlignConsecutiveTableGenBreakingDAGArgColons

AlignConsecutiveStyle clang::format::FormatStyle::AlignConsecutiveTableGenBreakingDAGArgColons

Style of aligning consecutive TableGen DAGArg operator colons.

If enabled, align the colon inside DAGArg which have line break inside. This works only when TableGenBreakInsideDAGArg is BreakElements or BreakAll and the DAGArg is not excepted by TableGenBreakingDAGArgOperators's effect.

let dagarg = (ins
    a  :$src1,
    aa :$src2,
    aaa:$src3
)

Version

19

Definition at line 454 of file Format.h.

AlignConsecutiveTableGenCondOperatorColons

AlignConsecutiveStyle clang::format::FormatStyle::AlignConsecutiveTableGenCondOperatorColons

Style of aligning consecutive TableGen cond operator colons.

Align the colons of cases inside !cond operators.

!cond(!eq(size, 1) : 1,
      !eq(size, 16): 1,
      true         : 0)

Version

19

Definition at line 464 of file Format.h.

AlignConsecutiveTableGenDefinitionColons

AlignConsecutiveStyle clang::format::FormatStyle::AlignConsecutiveTableGenDefinitionColons

Style of aligning consecutive TableGen definition colons.

This aligns the inheritance colons of consecutive definitions.

def Def       : Parent {}
def DefDef    : Parent {}
def DefDefDef : Parent {}

Version

19

Definition at line 474 of file Format.h.

AlignEscapedNewlines

EscapedNewlineAlignmentStyle clang::format::FormatStyle::AlignEscapedNewlines

Options for aligning backslashes in escaped newlines.

Version

5

Definition at line 515 of file Format.h.

AlignOperands

OperandAlignmentStyle clang::format::FormatStyle::AlignOperands

If true, horizontally align operands of binary and ternary expressions.

Version

3.5

Definition at line 554 of file Format.h.

AlignTrailingComments

TrailingCommentsAlignmentStyle clang::format::FormatStyle::AlignTrailingComments

Control of trailing comments.

The alignment stops at closing braces after a line break, and only followed by other closing braces, a (do-) while, a lambda call, or a semicolon.

Note

As of clang-format 16 this option is not a bool but can be set to the options. Conventional bool options still can be parsed as before. \endnote

# Example of usage:
AlignTrailingComments:
  Kind: Always
  OverEmptyLines: 2

Version

3.7

Definition at line 651 of file Format.h.

AllowAllArgumentsOnNextLine

bool clang::format::FormatStyle::AllowAllArgumentsOnNextLine

If a function call or braced initializer list doesn't fit on a line, allow putting all arguments onto the next line, even if BinPackArguments is false.

true:
callFunction(
    a, b, c, d);
 
false:
callFunction(a,
             b,
             c,
             d);

Version

9

Definition at line 668 of file Format.h.

AllowAllParametersOfDeclarationOnNextLine

bool clang::format::FormatStyle::AllowAllParametersOfDeclarationOnNextLine

This option is deprecated.

See NextLine of PackConstructorInitializers.

Version

9 If the function declaration doesn't fit on a line, allow putting all parameters of a function declaration onto the next line even if BinPackParameters is OnePerLine.

true:
void myFunction(
    int a, int b, int c, int d, int e);
 
false:
void myFunction(int a,
                int b,
                int c,
                int d,
                int e);

3.3

Definition at line 691 of file Format.h.

AllowBreakBeforeNoexceptSpecifier

BreakBeforeNoexceptSpecifierStyle clang::format::FormatStyle::AllowBreakBeforeNoexceptSpecifier

Controls if there could be a line break before a noexcept specifier.

Version

18

Definition at line 732 of file Format.h.

AllowBreakBeforeQtProperty

bool clang::format::FormatStyle::AllowBreakBeforeQtProperty

Allow breaking before Q_Property keywords READ, WRITE, etc.

as if they were preceded by a comma (,). This allows them to be formatted according to BinPackParameters.

Version

22

Definition at line 738 of file Format.h.

AllowShortBlocksOnASingleLine

ShortBlockStyle clang::format::FormatStyle::AllowShortBlocksOnASingleLine

Dependent on the value, while (true) { continue; } can be put on a single line.

Version

3.5

Definition at line 771 of file Format.h.

AllowShortCaseExpressionOnASingleLine

bool clang::format::FormatStyle::AllowShortCaseExpressionOnASingleLine

Whether to merge a short switch labeled rule into a single line.

true:                               false:
switch (a) {           vs.          switch (a) {
case 1 -> 1;                        case 1 ->
default -> 0;                         1;
};                                  default ->
                                      0;
                                    };

Version

19

Definition at line 784 of file Format.h.

AllowShortCaseLabelsOnASingleLine

bool clang::format::FormatStyle::AllowShortCaseLabelsOnASingleLine

If true, short case labels will be contracted to a single line.

true:                                   false:
switch (a) {                    vs.     switch (a) {
case 1: x = 1; break;                   case 1:
case 2: return;                           x = 1;
}                                         break;
                                        case 2:
                                          return;
                                        }

Version

3.6

Definition at line 798 of file Format.h.

AllowShortCompoundRequirementOnASingleLine

bool clang::format::FormatStyle::AllowShortCompoundRequirementOnASingleLine

Allow short compound requirement on a single line.

true:
template <typename T>
concept c = requires(T x) {
  { x + 1 } -> std::same_as<int>;
};
 
false:
template <typename T>
concept c = requires(T x) {
  {
    x + 1
  } -> std::same_as<int>;
};

Version

18

Definition at line 817 of file Format.h.

AllowShortEnumsOnASingleLine

bool clang::format::FormatStyle::AllowShortEnumsOnASingleLine

Allow short enums on a single line.

true:
enum { A, B } myEnum;
 
false:
enum {
  A,
  B
} myEnum;

Version

11

Definition at line 831 of file Format.h.

AllowShortFunctionsOnASingleLine

ShortFunctionStyle clang::format::FormatStyle::AllowShortFunctionsOnASingleLine

Dependent on the value, int f() { return 0; } can be put on a single line.

Version

3.5

Definition at line 956 of file Format.h.

AllowShortIfStatementsOnASingleLine

ShortIfStyle clang::format::FormatStyle::AllowShortIfStatementsOnASingleLine

Dependent on the value, if (a) return; can be put on a single line.

Version

3.3

Definition at line 1027 of file Format.h.

AllowShortLambdasOnASingleLine

ShortLambdaStyle clang::format::FormatStyle::AllowShortLambdasOnASingleLine

Dependent on the value, auto lambda []() { return 0; } can be put on a single line.

Version

9

Definition at line 1061 of file Format.h.

AllowShortLoopsOnASingleLine

bool clang::format::FormatStyle::AllowShortLoopsOnASingleLine

If true, while (true) continue; can be put on a single line.

Version

3.7

Definition at line 1066 of file Format.h.

AllowShortNamespacesOnASingleLine

bool clang::format::FormatStyle::AllowShortNamespacesOnASingleLine

If true, namespace a { class b; } can be put on a single line.

Version

20

Definition at line 1070 of file Format.h.

AllowShortRecordOnASingleLine

ShortRecordStyle clang::format::FormatStyle::AllowShortRecordOnASingleLine

Dependent on the value, struct bar { int i; }; can be put on a single line.

Version

23

Definition at line 1100 of file Format.h.

AlwaysBreakAfterDefinitionReturnType

DefinitionReturnTypeBreakingStyle clang::format::FormatStyle::AlwaysBreakAfterDefinitionReturnType

The function definition return type breaking style to use.

This option is deprecated and is retained for backwards compatibility.

Version

3.7

Definition at line 1211 of file Format.h.

AlwaysBreakBeforeMultilineStrings

bool clang::format::FormatStyle::AlwaysBreakBeforeMultilineStrings

This option is renamed to BreakAfterReturnType.

Version

3.8

Deprecated

If true, always break before multiline string literals.

This flag is mean to make cases where there are multiple multiline strings in a file look more consistent. Thus, it will only take effect if wrapping the string at that point leads to it being indented ContinuationIndentWidth spaces from the start of the line.

true:                                  false:
aaaa =                         vs.     aaaa = "bbbb"
    "bbbb"                                    "cccc";
    "cccc";

Version

3.4

Definition at line 1231 of file Format.h.

AttributeMacros

std::vector<std::string> clang::format::FormatStyle::AttributeMacros

This option is renamed to BreakTemplateDeclarations.

Version

3.4

Deprecated

A vector of strings that should be interpreted as attributes/qualifiers instead of identifiers. This can be useful for language extensions or static analyzer annotations.

For example:

x = (char *__capability)&y;
int function(void) __unused;
void only_writes_to_buffer(char *__output buffer);

In the .clang-format configuration file, this can be configured like:

AttributeMacros: [__capability, __output, __unused]

Version

12

Definition at line 1301 of file Format.h.

BinPackLongBracedList

bool clang::format::FormatStyle::BinPackLongBracedList

This option is deprecated.

See BinPack of PackArguments.

Version

3.7 If BinPackLongBracedList is true it overrides BinPackArguments if there are 20 or more items in a braced initializer list.

BinPackLongBracedList: false  vs.    BinPackLongBracedList: true
vector<int> x{                       vector<int> x{1, 2, ...,
                                                   20, 21};
            1,
            2,
            ...,
            20,
            21};

21

Definition at line 1321 of file Format.h.

BitFieldColonSpacing

BitFieldColonSpacingStyle clang::format::FormatStyle::BitFieldColonSpacing

The BitFieldColonSpacingStyle to use for bitfields.

Version

12

Definition at line 1354 of file Format.h.

BracedInitializerIndentWidth

int clang::format::FormatStyle::BracedInitializerIndentWidth

The number of columns to use to indent the contents of braced init lists.

If unset or negative, ContinuationIndentWidth is used.

AlignAfterOpenBracket: AlwaysBreak
BracedInitializerIndentWidth: 2
 
void f() {
  SomeClass c{
    "foo",
    "bar",
    "baz",
  };
  auto s = SomeStruct{
    .foo = "foo",
    .bar = "bar",
    .baz = "baz",
  };
  SomeArrayT a[3] = {
    {
      foo,
      bar,
    },
    {
      foo,
      bar,
    },
    SomeArrayT{},
  };
}

Version

17

Definition at line 1387 of file Format.h.

BraceWrapping

BraceWrappingFlags clang::format::FormatStyle::BraceWrapping

Control of individual brace wrapping cases.

If BreakBeforeBraces is set to Custom, use this to specify how each individual brace case should be handled. Otherwise, this is ignored.

# Example of usage:
BreakBeforeBraces: Custom
BraceWrapping:
  AfterEnum: true
  AfterStruct: false
  SplitEmptyFunction: false

Version

3.8

Definition at line 1668 of file Format.h.

BreakAdjacentStringLiterals

bool clang::format::FormatStyle::BreakAdjacentStringLiterals

Break between adjacent string literals.

true:
return "Code"
       "\0\52\26\55\55\0"
       "x013"
       "\02\xBA";
false:
return "Code" "\0\52\26\55\55\0" "x013" "\02\xBA";

Version

18

Definition at line 1681 of file Format.h.

BreakAfterAttributes

AttributeBreakingStyle clang::format::FormatStyle::BreakAfterAttributes

Break after a group of C++11 attributes before variable or function (including constructor/destructor) declaration/definition names or before control statements, i.e.

if, switch (including case and default labels), for, and while statements.

Version

16

Definition at line 1783 of file Format.h.

BreakAfterJavaFieldAnnotations

bool clang::format::FormatStyle::BreakAfterJavaFieldAnnotations

Break after each annotation on a field in Java files.

true:                                  false:
@Partial                       vs.     @Partial @Mock DataLoad loader;
@Mock
DataLoad loader;

Version

3.8

Definition at line 2714 of file Format.h.

BreakAfterOpenBracketBracedList

bool clang::format::FormatStyle::BreakAfterOpenBracketBracedList

Force break after the left bracket of a braced initializer list (when Cpp11BracedListStyle is true) when the list exceeds the column limit.

true:                             false:
vector<int> x {         vs.       vector<int> x {1,
   1, 2, 3}                            2, 3}

Version

22

Definition at line 1794 of file Format.h.

BreakAfterOpenBracketFunction

bool clang::format::FormatStyle::BreakAfterOpenBracketFunction

Force break after the left parenthesis of a function (declaration, definition, call) when the parameters exceed the column limit.

true:                             false:
foo (                   vs.       foo (a,
   a , b)                              b)

Version

22

Definition at line 1804 of file Format.h.

BreakAfterOpenBracketIf

bool clang::format::FormatStyle::BreakAfterOpenBracketIf

Force break after the left parenthesis of an if control statement when the expression exceeds the column limit.

true:                             false:
if constexpr (          vs.       if constexpr (a ||
   a || b)                                      b)

Version

22

Definition at line 1814 of file Format.h.

BreakAfterOpenBracketLoop

bool clang::format::FormatStyle::BreakAfterOpenBracketLoop

Force break after the left parenthesis of a loop control statement when the expression exceeds the column limit.

true:                             false:
while (                  vs.      while (a &&
   a && b) {                             b) {

Version

22

Definition at line 1824 of file Format.h.

BreakAfterOpenBracketSwitch

bool clang::format::FormatStyle::BreakAfterOpenBracketSwitch

Force break after the left parenthesis of a switch control statement when the expression exceeds the column limit.

true:                             false:
switch (                 vs.      switch (a +
   a + b) {                               b) {

Version

22

Definition at line 1834 of file Format.h.

BreakAfterReturnType

ReturnTypeBreakingStyle clang::format::FormatStyle::BreakAfterReturnType

The function declaration return type breaking style to use.

Version

19

Definition at line 1838 of file Format.h.

BreakArrays

bool clang::format::FormatStyle::BreakArrays

If true, clang-format will always break after a Json array [ otherwise it will scan until the closing ] to determine if it should add newlines between elements (prettier compatible).

Note

This is currently only for formatting JSON. \endnote

true:                                  false:
[                          vs.      [1, 2, 3, 4]
  1,
  2,
  3,
  4
]

Version

16

Definition at line 1857 of file Format.h.

BreakBeforeBinaryOperators

BinaryOperatorStyle clang::format::FormatStyle::BreakBeforeBinaryOperators

The way to wrap binary operators.

Version

3.6

Definition at line 1912 of file Format.h.

BreakBeforeBraces

BraceBreakingStyle clang::format::FormatStyle::BreakBeforeBraces

The brace breaking style to use.

Version

3.7

Definition at line 2347 of file Format.h.

BreakBeforeCloseBracketBracedList

bool clang::format::FormatStyle::BreakBeforeCloseBracketBracedList

Force break before the right bracket of a braced initializer list (when Cpp11BracedListStyle is true) when the list exceeds the column limit.

The break before the right bracket is only made if there is a break after the opening bracket.

true:                             false:
vector<int> x {         vs.       vector<int> x {
   1, 2, 3                           1, 2, 3}
}

Version

22

Definition at line 2360 of file Format.h.

BreakBeforeCloseBracketFunction

bool clang::format::FormatStyle::BreakBeforeCloseBracketFunction

Force break before the right parenthesis of a function (declaration, definition, call) when the parameters exceed the column limit.

true:                             false:
foo (                   vs.       foo (
   a , b                             a , b)
)

Version

22

Definition at line 2371 of file Format.h.

BreakBeforeCloseBracketIf

bool clang::format::FormatStyle::BreakBeforeCloseBracketIf

Force break before the right parenthesis of an if control statement when the expression exceeds the column limit.

The break before the closing parenthesis is only made if there is a break after the opening parenthesis.

true:                             false:
if constexpr (          vs.       if constexpr (
   a || b                            a || b )
)

Version

22

Definition at line 2384 of file Format.h.

BreakBeforeCloseBracketLoop

bool clang::format::FormatStyle::BreakBeforeCloseBracketLoop

Force break before the right parenthesis of a loop control statement when the expression exceeds the column limit.

The break before the closing parenthesis is only made if there is a break after the opening parenthesis.

true:                             false:
while (                  vs.      while (
   a && b                            a && b) {
) {

Version

22

Definition at line 2397 of file Format.h.

BreakBeforeCloseBracketSwitch

bool clang::format::FormatStyle::BreakBeforeCloseBracketSwitch

Force break before the right parenthesis of a switch control statement when the expression exceeds the column limit.

The break before the closing parenthesis is only made if there is a break after the opening parenthesis.

true:                             false:
switch (                 vs.      switch (
   a + b                             a + b) {
) {

Version

22

Definition at line 2410 of file Format.h.

BreakBeforeConceptDeclarations

BreakBeforeConceptDeclarationsStyle clang::format::FormatStyle::BreakBeforeConceptDeclarations

The concept declaration style to use.

Version

12

Definition at line 2434 of file Format.h.

BreakBeforeInlineASMColon

BreakBeforeInlineASMColonStyle clang::format::FormatStyle::BreakBeforeInlineASMColon

The inline ASM colon style to use.

Version

16

Definition at line 2463 of file Format.h.

BreakBeforeReturnType

BreakBeforeReturnTypeStyle clang::format::FormatStyle::BreakBeforeReturnType

The function declaration/definition return type breaking style to use.

Trailing return types (auto f() -> T) are not affected. To have identifier macros (e.g. __always_inline) treated as specifiers, add them to AttributeMacros.

Version

23

Definition at line 2488 of file Format.h.

BreakBeforeTemplateCloser

bool clang::format::FormatStyle::BreakBeforeTemplateCloser

If true, break before a template closing bracket (>) when there is a line break after the matching opening bracket (<).

true:
template <typename Foo, typename Bar>
 
template <typename Foo,
          typename Bar>
 
template <
    typename Foo,
    typename Bar
>
 
false:
template <typename Foo, typename Bar>
 
template <typename Foo,
          typename Bar>
 
template <
    typename Foo,
    typename Bar>

Version

21

Definition at line 2515 of file Format.h.

BreakBeforeTernaryOperators

bool clang::format::FormatStyle::BreakBeforeTernaryOperators

If true, ternary operators will be placed after line breaks.

true:
veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
    ? firstValue
    : SecondValueVeryVeryVeryVeryLong;
 
false:
veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
    firstValue :
    SecondValueVeryVeryVeryVeryLong;

Version

3.7

Definition at line 2530 of file Format.h.

BreakBinaryOperations

BreakBinaryOperationsOptions clang::format::FormatStyle::BreakBinaryOperations

The break binary operations style to use.

Version

20

Definition at line 2640 of file Format.h.

BreakConstructorInitializers

BreakConstructorInitializersStyle clang::format::FormatStyle::BreakConstructorInitializers

The break constructor initializers style to use.

Version

5

Definition at line 2676 of file Format.h.

BreakFunctionDeclarationParameters

bool clang::format::FormatStyle::BreakFunctionDeclarationParameters

If true, clang-format will always break before function declaration parameters.

true:
void functionDeclaration(
         int A, int B);
 
false:
void functionDeclaration(int A, int B);

Version

23

Definition at line 2690 of file Format.h.

BreakFunctionDefinitionParameters

bool clang::format::FormatStyle::BreakFunctionDefinitionParameters

If true, clang-format will always break before function definition parameters.

true:
void functionDefinition(
         int A, int B) {}
 
false:
void functionDefinition(int A, int B) {}

Version

19

Definition at line 2704 of file Format.h.

BreakInheritanceList

BreakInheritanceListStyle clang::format::FormatStyle::BreakInheritanceList

The inheritance list style to use.

Version

7

Definition at line 2815 of file Format.h.

BreakStringLiterals

bool clang::format::FormatStyle::BreakStringLiterals

Allow breaking string literals when formatting.

In C, C++, and Objective-C:

true:
const char* x = "veryVeryVeryVeryVeryVe"
                "ryVeryVeryVeryVeryVery"
                "VeryLongString";
 
false:
const char* x =
    "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";

In C# and Java:

true:
string x = "veryVeryVeryVeryVeryVe" +
           "ryVeryVeryVeryVeryVery" +
           "VeryLongString";
 
false:
string x =
    "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";

C# interpolated strings are not broken.

In Verilog:

true:
string x = {"veryVeryVeryVeryVeryVe",
            "ryVeryVeryVeryVeryVery",
            "VeryLongString"};
 
false:
string x =
    "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";

Version

3.9

Definition at line 2757 of file Format.h.

BreakTemplateDeclarations

BreakTemplateDeclarationsStyle clang::format::FormatStyle::BreakTemplateDeclarations

The template declaration breaking style to use.

Version

19

Definition at line 2819 of file Format.h.

ColumnLimit

unsigned clang::format::FormatStyle::ColumnLimit

The column limit.

A column limit of 0 means that there is no column limit. In this case, clang-format will respect the input's line breaking decisions within statements unless they contradict other rules.

Version

3.7

Definition at line 2765 of file Format.h.

CommentPragmas

std::string clang::format::FormatStyle::CommentPragmas

A regular expression that describes comments with special meaning, which should not be split into lines or otherwise changed.

// CommentPragmas: '^ FOOBAR pragma:'
// Will leave the following line unaffected
#include <vector> // FOOBAR pragma: keep

Version

3.7

Definition at line 2775 of file Format.h.

CompactNamespaces

bool clang::format::FormatStyle::CompactNamespaces

If true, consecutive namespace declarations will be on the same line.

If false, each namespace is declared on a new line.

true:
namespace Foo { namespace Bar {
}}
 
false:
namespace Foo {
namespace Bar {
}
}

If it does not fit on a single line, the overflowing namespaces get wrapped:

namespace Foo { namespace Bar {
namespace Extra {
}}}

Version

5

Definition at line 2843 of file Format.h.

ConstructorInitializerIndentWidth

unsigned clang::format::FormatStyle::ConstructorInitializerIndentWidth

This option is deprecated.

See CurrentLine of PackConstructorInitializers.

Version

3.7 The number of characters to use for indentation of constructor initializer lists as well as inheritance lists.

3.7

Definition at line 2853 of file Format.h.

ContinuationIndentWidth

unsigned clang::format::FormatStyle::ContinuationIndentWidth

Indent width for line continuations.

ContinuationIndentWidth: 2
 
int i =         //  VeryVeryVeryVeryVeryLongComment
  longFunction( // Again a long comment
    arg);

Version

3.7

Definition at line 2864 of file Format.h.

Cpp11BracedListStyle

BracedListStyle clang::format::FormatStyle::Cpp11BracedListStyle

The style to handle braced lists.

Version

3.4

Definition at line 2926 of file Format.h.

DerivePointerAlignment

bool clang::format::FormatStyle::DerivePointerAlignment

This option is deprecated.

See DeriveLF and DeriveCRLF of LineEnding.

Version

10 If true, analyze the formatted file for the most common alignment of & and *. Pointer and reference alignment styles are going to be updated according to the preferences found in the file. PointerAlignment is then used only as fallback.

3.7

Definition at line 2939 of file Format.h.

DisableFormat

bool clang::format::FormatStyle::DisableFormat

Disables formatting completely.

Version

3.7

Definition at line 2943 of file Format.h.

EmptyLineAfterAccessModifier

EmptyLineAfterAccessModifierStyle clang::format::FormatStyle::EmptyLineAfterAccessModifier

Defines when to put an empty line after access modifiers.

EmptyLineBeforeAccessModifier configuration handles the number of empty lines between two access modifiers.

Version

13

Definition at line 2994 of file Format.h.

EmptyLineBeforeAccessModifier

EmptyLineBeforeAccessModifierStyle clang::format::FormatStyle::EmptyLineBeforeAccessModifier

Defines in which cases to put empty line before access modifiers.

Version

12

Definition at line 3057 of file Format.h.

EnumTrailingComma

EnumTrailingCommaStyle clang::format::FormatStyle::EnumTrailingComma

Insert a comma (if missing) or remove the comma at the end of an enum enumerator list.

Warning

Setting this option to any value other than Leave could lead to incorrect code formatting due to clang-format's lack of complete semantic information. As such, extra care should be taken to review code changes made by this option. \endwarning

Version

21

Definition at line 3090 of file Format.h.

ExperimentalAutoDetectBinPacking

bool clang::format::FormatStyle::ExperimentalAutoDetectBinPacking

If true, clang-format detects whether function calls and definitions are formatted with one parameter per line.

Each call can be bin-packed, one-per-line or inconclusive. If it is inconclusive, e.g. completely on one line, but a decision needs to be made, clang-format analyzes whether there are other bin-packed cases in the input file and act accordingly.

Note

This is an experimental flag, that might go away or be renamed. Do not use this in config files, etc. Use at your own risk. \endnote

Version

3.7

Definition at line 3105 of file Format.h.

FixNamespaceComments

bool clang::format::FormatStyle::FixNamespaceComments

If true, clang-format adds missing namespace end comments for namespaces and fixes invalid existing ones.

This doesn't affect short namespaces, which are controlled by ShortNamespaceLines.

true:                                  false:
namespace longNamespace {      vs.     namespace longNamespace {
void foo();                            void foo();
void bar();                            void bar();
} // namespace a                       }
namespace shortNamespace {             namespace shortNamespace {
void baz();                            void baz();
}                                      }

Version

5

Definition at line 3121 of file Format.h.

ForEachMacros

std::vector<std::string> clang::format::FormatStyle::ForEachMacros

A vector of macros that should be interpreted as foreach loops instead of as function calls.

These are expected to be macros of the form:

FOREACH(<variable-declaration>, ...)
  <loop-body>

In the .clang-format configuration file, this can be configured like:

ForEachMacros: [RANGES_FOR, FOREACH]

For example: BOOST_FOREACH.

Version

3.7

Definition at line 3139 of file Format.h.

IfMacros

std::vector<std::string> clang::format::FormatStyle::IfMacros

A vector of macros that should be interpreted as conditionals instead of as function calls.

These are expected to be macros of the form:

IF(...)
  <conditional-body>
else IF(...)
  <conditional-body>

In the .clang-format configuration file, this can be configured like:

IfMacros: [IF]

For example: KJ_IF_MAYBE

Version

13

Definition at line 3162 of file Format.h.

IncludeStyle

tooling::IncludeStyle clang::format::FormatStyle::IncludeStyle

Definition at line 3141 of file Format.h.

IndentAccessModifiers

bool clang::format::FormatStyle::IndentAccessModifiers

Specify whether access modifiers should have their own indentation level.

When false, access modifiers are indented (or outdented) relative to the record members, respecting the AccessModifierOffset. Record members are indented one level below the record. When true, access modifiers get their own indentation level. As a consequence, record members are always indented 2 levels below the record, regardless of the access modifier presence. Value of the AccessModifierOffset is ignored.

false:                                 true:
class C {                      vs.     class C {
  class D {                                class D {
    void bar();                                void bar();
  protected:                                 protected:
    D();                                       D();
  };                                       };
public:                                  public:
  C();                                     C();
};                                     };
void foo() {                           void foo() {
  return 1;                              return 1;
}                                      }

Version

13

Definition at line 3189 of file Format.h.

IndentCaseBlocks

bool clang::format::FormatStyle::IndentCaseBlocks

Indent case label blocks one level from the case label.

When false, the block following the case label uses the same indentation level as for the case label, treating the case label the same as an if-statement. When true, the block gets indented as a scope block.

false:                                 true:
switch (fool) {                vs.     switch (fool) {
case 1: {                              case 1:
  bar();                                 {
} break;                                   bar();
default: {                               }
  plop();                                break;
}                                      default:
}                                        {
                                           plop();
                                         }
                                       }

Version

11

Definition at line 3212 of file Format.h.

IndentCaseLabels

bool clang::format::FormatStyle::IndentCaseLabels

Indent case labels one level from the switch statement.

When false, use the same indentation level as for the switch statement. Switch statement body is always indented one level more than case labels (except the first block following the case label, which itself indents the code - unless IndentCaseBlocks is enabled).

false:                                 true:
switch (fool) {                vs.     switch (fool) {
case 1:                                  case 1:
  bar();                                   bar();
  break;                                   break;
default:                                 default:
  plop();                                  plop();
}                                      }

Version

3.3

Definition at line 3231 of file Format.h.

IndentExportBlock

bool clang::format::FormatStyle::IndentExportBlock

If true, clang-format will indent the body of an export { ... } block.

This doesn't affect the formatting of anything else related to exported declarations.

true:                     false:
export {          vs.     export {
  void foo();             void foo();
  void bar();             void bar();
}                         }

Version

20

Definition at line 3244 of file Format.h.

IndentExternBlock

IndentExternBlockStyle clang::format::FormatStyle::IndentExternBlock

IndentExternBlockStyle is the type of indenting of extern blocks.

Version

11

Definition at line 3284 of file Format.h.

IndentGotoLabels

IndentGotoLabelStyle clang::format::FormatStyle::IndentGotoLabels

The goto label indenting style to use.

Version

10

Definition at line 3342 of file Format.h.

IndentPPDirectives

PPDirectiveIndentStyle clang::format::FormatStyle::IndentPPDirectives

The preprocessor directive indenting style to use.

Version

6

Definition at line 3389 of file Format.h.

IndentRequiresClause

bool clang::format::FormatStyle::IndentRequiresClause

Indent the requires clause in a template.

This only applies when RequiresClausePosition is OwnLine, OwnLineWithBrace, or WithFollowing.

In clang-format 12, 13 and 14 it was named IndentRequires.

true:
template <typename It>
  requires Iterator<It>
void sort(It begin, It end) {
  //....
}
 
false:
template <typename It>
requires Iterator<It>
void sort(It begin, It end) {
  //....
}

Version

15

Definition at line 3412 of file Format.h.

IndentWidth

unsigned clang::format::FormatStyle::IndentWidth

The number of columns to use for indentation.

IndentWidth: 3
 
void f() {
   someFunction();
   if (true, false) {
      f();
   }
}

Version

3.7

Definition at line 3426 of file Format.h.

IndentWrappedFunctionNames

bool clang::format::FormatStyle::IndentWrappedFunctionNames

Indent if a function definition or declaration is wrapped after the type.

true:
LoooooooooooooooooooooooooooooooooooooooongReturnType
    LoooooooooooooooooooooooooooooooongFunctionDeclaration();
 
false:
LoooooooooooooooooooooooooooooooooooooooongReturnType
LoooooooooooooooooooooooooooooooongFunctionDeclaration();

Version

3.7

Definition at line 3440 of file Format.h.

InheritConfig

std::string clang::format::FormatStyle::InheritConfig

Definition at line 60 of file Format.h.

InsertBraces

bool clang::format::FormatStyle::InsertBraces

Insert braces after control statements (if, else, for, do, and while) in C++ unless the control statements are inside macro definitions or the braces would enclose preprocessor directives.

Warning

Setting this option to true could lead to incorrect code formatting due to clang-format's lack of complete semantic information. As such, extra care should be taken to review code changes made by this option. \endwarning

false:                                    true:
 
if (isa<FunctionDecl>(D))        vs.      if (isa<FunctionDecl>(D)) {
  handleFunctionDecl(D);                    handleFunctionDecl(D);
else if (isa<VarDecl>(D))                 } else if (isa<VarDecl>(D)) {
  handleVarDecl(D);                         handleVarDecl(D);
else                                      } else {
  return;                                   return;
                                          }
 
while (i--)                      vs.      while (i--) {
  for (auto *A : D.attrs())                 for (auto *A : D.attrs()) {
    handleAttr(A);                            handleAttr(A);
                                            }
                                          }
 
do                               vs.      do {
  --i;                                      --i;
while (i);                                } while (i);

Version

15

Definition at line 3472 of file Format.h.

InsertNewlineAtEOF

bool clang::format::FormatStyle::InsertNewlineAtEOF

Insert a newline at end of file if missing.

Version

16

Definition at line 3476 of file Format.h.

InsertTrailingCommas

TrailingCommaStyle clang::format::FormatStyle::InsertTrailingCommas

If set to TCS_Wrapped will insert trailing commas in container literals (arrays and objects) that wrap across multiple lines.

It is currently only available for JavaScript and disabled by default TCS_None. InsertTrailingCommas cannot be used together with BinPackArguments as inserting the comma disables bin-packing.

TSC_Wrapped:
const someArray = [
aaaaaaaaaaaaaaaaaaaaaaaaaa,
aaaaaaaaaaaaaaaaaaaaaaaaaa,
aaaaaaaaaaaaaaaaaaaaaaaaaa,
//                        ^ inserted
]

Version

11

Definition at line 3506 of file Format.h.

IntegerLiteralSeparator

IntegerLiteralSeparatorStyle clang::format::FormatStyle::IntegerLiteralSeparator

Format integer literal separators (‘’ for C/C++ and _` for C#, Java, and JavaScript).

Version

16

Definition at line 3641 of file Format.h.

JavaImportGroups

std::vector<std::string> clang::format::FormatStyle::JavaImportGroups

A vector of prefixes ordered by the desired groups for Java imports.

One group's prefix can be a subset of another - the longest prefix is always matched. Within a group, the imports are ordered lexicographically. Static imports are grouped separately and follow the same group rules. By default, static imports are placed before non-static imports, but this behavior is changed by another option, SortJavaStaticImport.

In the .clang-format configuration file, this can be configured like in the following yaml example. This will result in imports being formatted as in the Java example below.

JavaImportGroups: [com.example, com, org]

import static com.example.function1;
 
import static com.test.function2;
 
import static org.example.function3;
 
import com.example.ClassA;
import com.example.Test;
import com.example.a.ClassB;
 
import com.test.ClassC;
 
import org.example.ClassD;

Version

8

Definition at line 3675 of file Format.h.

JavaScriptQuotes

JavaScriptQuoteStyle clang::format::FormatStyle::JavaScriptQuotes

The JavaScriptQuoteStyle to use for JavaScript strings.

Version

3.9

Definition at line 3702 of file Format.h.

JavaScriptWrapImports

bool clang::format::FormatStyle::JavaScriptWrapImports

Whether to wrap JavaScript import/export statements.

true:
import {
    VeryLongImportsAreAnnoying,
    VeryLongImportsAreAnnoying,
    VeryLongImportsAreAnnoying,
} from "some/module.js"
 
false:
import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js"

Version

3.9

Definition at line 3718 of file Format.h.

KeepEmptyLines

KeepEmptyLinesStyle clang::format::FormatStyle::KeepEmptyLines

Which empty lines are kept.

See MaxEmptyLinesToKeep for how many consecutive empty lines are kept.

Version

19

Definition at line 3755 of file Format.h.

KeepFormFeed

bool clang::format::FormatStyle::KeepFormFeed

This option is deprecated.

See AtEndOfFile of KeepEmptyLines.

Version

17 This option is deprecated. See AtStartOfBlock of KeepEmptyLines.

3.7 Keep the form feed character if it's immediately preceded and followed by a newline. Multiple form feeds and newlines within a whitespace range are replaced with a single newline and form feed followed by the remaining newlines. (See www.gnu.org/prep/standards/html_node/Formatting.html#:~:text=formfeed.)

20

Definition at line 3772 of file Format.h.

LambdaBodyIndentation

LambdaBodyIndentationKind clang::format::FormatStyle::LambdaBodyIndentation

The indentation style of lambda bodies.

Signature (the default) causes the lambda body to be indented one additional level relative to the indentation level of the signature. OuterScope forces the lambda body to be indented one additional level relative to the parent scope containing the lambda signature.

Version

13

Definition at line 3806 of file Format.h.

Language

LanguageKind clang::format::FormatStyle::Language

The language that this format style targets.

Note

You can specify the language (C, Cpp, or ObjC) for .h files by adding a // clang-format Language: line before the first non-comment (and non-empty) line, e.g. // clang-format Language: Cpp. \endnote

Version

3.5

Definition at line 3861 of file Format.h.

LineEnding

LineEndingStyle clang::format::FormatStyle::LineEnding

Line ending style (\n or \r\n) to use.

Version

16

Definition at line 3877 of file Format.h.

MacroBlockBegin

std::string clang::format::FormatStyle::MacroBlockBegin

A regular expression matching macros that start a block.

# With:
MacroBlockBegin: "^NS_MAP_BEGIN|\
NS_TABLE_HEAD$"
MacroBlockEnd: "^\
NS_MAP_END|\
NS_TABLE_.*_END$"
 
NS_MAP_BEGIN
  foo();
NS_MAP_END
 
NS_TABLE_HEAD
  bar();
NS_TABLE_FOO_END
 
# Without:
NS_MAP_BEGIN
foo();
NS_MAP_END
 
NS_TABLE_HEAD
bar();
NS_TABLE_FOO_END

Version

3.7

Definition at line 3902 of file Format.h.

MacroBlockEnd

std::string clang::format::FormatStyle::MacroBlockEnd

A regular expression matching macros that end a block.

Version

3.7

Definition at line 3906 of file Format.h.

Macros

std::vector<std::string> clang::format::FormatStyle::Macros

A list of macros of the form <definition>=<expansion> .

Code will be parsed with macros expanded, in order to determine how to interpret and format the macro arguments.

For example, the code:

A(a*b);

will usually be interpreted as a call to a function A, and the multiplication expression will be formatted as a * b.

If we specify the macro definition:

Macros:
- A(x)=x

the code will now be parsed as a declaration of the variable b of type a*, and formatted as a* b (depending on pointer-binding rules).

Features and restrictions:

• Both function-like macros and object-like macros are supported.
• Macro arguments must be used exactly once in the expansion.
• No recursive expansion; macros referencing other macros will be ignored.
• Overloading by arity is supported: for example, given the macro definitions A=x, A()=y, A(a)=a

A; -> x;
A(); -> y;
A(z); -> z;
A(a, b); // will not be expanded.

Version

17

Definition at line 3947 of file Format.h.

MacrosSkippedByRemoveParentheses

std::vector<std::string> clang::format::FormatStyle::MacrosSkippedByRemoveParentheses

A vector of function-like macros whose invocations should be skipped by RemoveParentheses.

Version

21

Definition at line 3952 of file Format.h.

MaxEmptyLinesToKeep

unsigned clang::format::FormatStyle::MaxEmptyLinesToKeep

The maximum number of consecutive empty lines to keep.

MaxEmptyLinesToKeep: 1         vs.     MaxEmptyLinesToKeep: 0
int f() {                              int f() {
  int = 1;                                 int i = 1;
                                           i = foo();
  i = foo();                               return i;
                                       }
  return i;
}

Version

3.7

Definition at line 3966 of file Format.h.

NamespaceIndentation

NamespaceIndentationKind clang::format::FormatStyle::NamespaceIndentation

The indentation used for namespaces.

Version

3.7

Definition at line 4004 of file Format.h.

NamespaceMacros

std::vector<std::string> clang::format::FormatStyle::NamespaceMacros

A vector of macros which are used to open namespace blocks.

These are expected to be macros of the form:

NAMESPACE(<namespace-name>, ...) {
  <namespace-content>
}

For example: TESTSUITE

Version

9

Definition at line 4017 of file Format.h.

NumericLiteralCase

NumericLiteralCaseStyle clang::format::FormatStyle::NumericLiteralCase

Capitalization style for numeric literals.

Version

22

Definition at line 4084 of file Format.h.

ObjCBinPackProtocolList

BinPackStyle clang::format::FormatStyle::ObjCBinPackProtocolList

Controls bin-packing Objective-C protocol conformance list items into as few lines as possible when they go over ColumnLimit.

If Auto (the default), delegates to the value in BinPackParameters. If that is BinPack, bin-packs Objective-C protocol conformance list items into as few lines as possible whenever they go over ColumnLimit.

If Always, always bin-packs Objective-C protocol conformance list items into as few lines as possible whenever they go over ColumnLimit.

If Never, lays out Objective-C protocol conformance list items onto individual lines whenever they go over ColumnLimit.

Always (or Auto, if BinPackParameters==BinPack):
@interface ccccccccccccc () <
    ccccccccccccc, ccccccccccccc,
    ccccccccccccc, ccccccccccccc> {
}
 
Never (or Auto, if BinPackParameters!=BinPack):
@interface ddddddddddddd () <
    ddddddddddddd,
    ddddddddddddd,
    ddddddddddddd,
    ddddddddddddd> {
}

Version

7

Definition at line 4117 of file Format.h.

ObjCBlockIndentWidth

unsigned clang::format::FormatStyle::ObjCBlockIndentWidth

The number of characters to use for indentation of ObjC blocks.

ObjCBlockIndentWidth: 4
 
[operation setCompletionBlock:^{
    [self onOperationDone];
}];

Version

3.7

Definition at line 4128 of file Format.h.

ObjCBreakBeforeNestedBlockParam

bool clang::format::FormatStyle::ObjCBreakBeforeNestedBlockParam

Break parameters list into lines when there is nested block parameters in a function call.

false:
 - (void)_aMethod
 {
     [self.test1 t:self w:self callback:^(typeof(self) self, NSNumber
     *u, NSNumber *v) {
         u = c;
     }]
 }
 true:
 - (void)_aMethod
 {
    [self.test1 t:self
                 w:self
        callback:^(typeof(self) self, NSNumber *u, NSNumber *v) {
             u = c;
         }]
 }

Version

11

Definition at line 4152 of file Format.h.

ObjCPropertyAttributeOrder

std::vector<std::string> clang::format::FormatStyle::ObjCPropertyAttributeOrder

The order in which ObjC property attributes should appear.

Attributes in code will be sorted in the order specified. Any attributes encountered that are not mentioned in this array will be sorted last, in stable order. Comments between attributes will leave the attributes untouched.

Warning

Using this option could lead to incorrect code formatting due to clang-format's lack of complete semantic information. As such, extra care should be taken to review code changes made by this option. \endwarning

ObjCPropertyAttributeOrder: [
    class, direct,
    atomic, nonatomic,
    assign, retain, strong, copy, weak, unsafe_unretained,
    readonly, readwrite, getter, setter,
    nullable, nonnull, null_resettable, null_unspecified
]

Version

18

Definition at line 4175 of file Format.h.

ObjCSpaceAfterMethodDeclarationPrefix

bool clang::format::FormatStyle::ObjCSpaceAfterMethodDeclarationPrefix

Add or remove a space between the '-'/'+' and the return type in Objective-C method declarations.

i.e

false:                      true:
 
-(void)method      vs.      - (void)method

Version

23

Definition at line 4185 of file Format.h.

ObjCSpaceAfterProperty

bool clang::format::FormatStyle::ObjCSpaceAfterProperty

Add a space after @property in Objective-C, i.e.

use @property (readonly) instead of @property(readonly).

Version

3.7

Definition at line 4190 of file Format.h.

ObjCSpaceBeforeProtocolList

bool clang::format::FormatStyle::ObjCSpaceBeforeProtocolList

Add a space in front of an Objective-C protocol list, i.e.

use Foo <Protocol> instead of Foo<Protocol>.

Version

3.7

Definition at line 4195 of file Format.h.

OneLineFormatOffRegex

std::string clang::format::FormatStyle::OneLineFormatOffRegex

A regular expression that describes markers for turning formatting off for one line.

If it matches a comment that is the only token of a line, clang-format skips the comment and the next line. Otherwise, clang-format skips lines containing a matched token.

Note

This option does not apply to IntegerLiteralSeparator and NumericLiteralCase. \endnote

// OneLineFormatOffRegex: ^(// NOLINT|logger$)
// results in the output below:
int a;
int b ;  // NOLINT
int c;
 // NOLINTNEXTLINE
int d ;
int e;
s = "// NOLINT";
 logger() ;
logger2();
my_logger();

Version

21

Definition at line 4220 of file Format.h.

PackArguments

PackArgumentsStyle clang::format::FormatStyle::PackArguments

Options related to packing arguments of function calls.

Version

23

Definition at line 4286 of file Format.h.

PackConstructorInitializers

PackConstructorInitializersStyle clang::format::FormatStyle::PackConstructorInitializers

The pack constructor initializers style to use.

Version

14

Definition at line 4348 of file Format.h.

PackParameters

PackParametersStyle clang::format::FormatStyle::PackParameters

Options related to packing parameters of function declarations and definitions.

Version

23

Definition at line 4419 of file Format.h.

PenaltyBreakAssignment

unsigned clang::format::FormatStyle::PenaltyBreakAssignment

The penalty for breaking around an assignment operator.

Version

5

Definition at line 4423 of file Format.h.

PenaltyBreakBeforeFirstCallParameter

unsigned clang::format::FormatStyle::PenaltyBreakBeforeFirstCallParameter

The penalty for breaking a function call after call(.

Version

3.7

Definition at line 4427 of file Format.h.

PenaltyBreakBeforeMemberAccess

unsigned clang::format::FormatStyle::PenaltyBreakBeforeMemberAccess

The penalty for breaking before a member access operator (.

, ->).

Version

20

Definition at line 4431 of file Format.h.

PenaltyBreakComment

unsigned clang::format::FormatStyle::PenaltyBreakComment

The penalty for each line break introduced inside a comment.

Version

3.7

Definition at line 4435 of file Format.h.

PenaltyBreakFirstLessLess

unsigned clang::format::FormatStyle::PenaltyBreakFirstLessLess

The penalty for breaking before the first <<.

Version

3.7

Definition at line 4439 of file Format.h.

PenaltyBreakOpenParenthesis

unsigned clang::format::FormatStyle::PenaltyBreakOpenParenthesis

The penalty for breaking after (.

Version

14

Definition at line 4443 of file Format.h.

PenaltyBreakScopeResolution

unsigned clang::format::FormatStyle::PenaltyBreakScopeResolution

The penalty for breaking after ::.

Version

18

Definition at line 4447 of file Format.h.

PenaltyBreakString

unsigned clang::format::FormatStyle::PenaltyBreakString

The penalty for each line break introduced inside a string literal.

Version

3.7

Definition at line 4451 of file Format.h.

PenaltyBreakTemplateDeclaration

unsigned clang::format::FormatStyle::PenaltyBreakTemplateDeclaration

The penalty for breaking after template declaration.

Version

7

Definition at line 4455 of file Format.h.

PenaltyExcessCharacter

unsigned clang::format::FormatStyle::PenaltyExcessCharacter

The penalty for each character outside of the column limit.

Version

3.7

Definition at line 4459 of file Format.h.

PenaltyIndentedWhitespace

unsigned clang::format::FormatStyle::PenaltyIndentedWhitespace

Penalty for each character of whitespace indentation (counted relative to leading non-whitespace column).

Version

12

Definition at line 4464 of file Format.h.

PenaltyReturnTypeOnItsOwnLine

unsigned clang::format::FormatStyle::PenaltyReturnTypeOnItsOwnLine

Penalty for putting the return type of a function onto its own line.

Version

3.7

Definition at line 4468 of file Format.h.

PointerAlignment

PointerAlignmentStyle clang::format::FormatStyle::PointerAlignment

Pointer and reference alignment style.

Version

3.7

Definition at line 4491 of file Format.h.

PPIndentWidth

int clang::format::FormatStyle::PPIndentWidth

The number of columns to use for indentation of preprocessor statements.

When set to -1 (default) IndentWidth is used also for preprocessor statements.

PPIndentWidth: 1
 
#ifdef __linux__
# define FOO
#else
# define BAR
#endif

Version

13

Definition at line 4506 of file Format.h.

QualifierAlignment

QualifierAlignmentStyle clang::format::FormatStyle::QualifierAlignment

Different ways to arrange specifiers and qualifiers (e.g.

const/volatile).

Warning

Setting QualifierAlignment to something other than Leave, COULD lead to incorrect code formatting due to incorrect decisions made due to clang-formats lack of complete semantic information. As such extra care should be taken to review code changes made by the use of this option. \endwarning

Version

14

Definition at line 4552 of file Format.h.

QualifierOrder

std::vector<std::string> clang::format::FormatStyle::QualifierOrder

The order in which the qualifiers appear.

The order is an array that can contain any of the following:

• const
• inline
• static
• friend
• constexpr
• volatile
• restrict
• type

Note

It must contain type. \endnote

Items to the left of type will be placed to the left of the type and aligned in the order supplied. Items to the right of type will be placed to the right of the type and aligned in the order supplied.

QualifierOrder: [inline, static, type, const, volatile]

Version

14

Definition at line 4578 of file Format.h.

RawStringFormats

std::vector<RawStringFormat> clang::format::FormatStyle::RawStringFormats

Defines hints for detecting supported languages code blocks in raw strings.

A raw string with a matching delimiter or a matching enclosing function name will be reformatted assuming the specified language based on the style for that language defined in the .clang-format file. If no style has been defined in the .clang-format file for the specific language, a predefined style given by BasedOnStyle is used. If BasedOnStyle is not found, the formatting is based on LLVM style. A matching delimiter takes precedence over a matching enclosing function name for determining the language of the raw string contents.

If a canonical delimiter is specified, occurrences of other delimiters for the same language will be updated to the canonical if possible.

There should be at most one specification per language and each delimiter and enclosing function should not occur in multiple specifications.

To configure this in the .clang-format file, use:

RawStringFormats:
  - Language: TextProto
      Delimiters:
        - pb
        - proto
      EnclosingFunctions:
        - PARSE_TEXT_PROTO
      BasedOnStyle: google
  - Language: Cpp
      Delimiters:
        - cc
        - cpp
      BasedOnStyle: LLVM
      CanonicalDelimiter: cc

Version

6

Definition at line 4638 of file Format.h.

ReferenceAlignment

ReferenceAlignmentStyle clang::format::FormatStyle::ReferenceAlignment

Reference alignment style (overrides PointerAlignment for references).

Version

13

Definition at line 4663 of file Format.h.

ReflowComments

ReflowCommentsStyle clang::format::FormatStyle::ReflowComments

Comment reformatting style.

Version

3.8

Definition at line 4701 of file Format.h.

RemoveBracesLLVM

bool clang::format::FormatStyle::RemoveBracesLLVM

Remove optional braces of control statements (if, else, for, and while) in C++ according to the LLVM coding style.

Warning

This option will be renamed and expanded to support other styles. \endwarning

Setting this option to true could lead to incorrect code formatting due to clang-format's lack of complete semantic information. As such, extra care should be taken to review code changes made by this option. \endwarning

false:                                     true:
 
if (isa<FunctionDecl>(D)) {        vs.     if (isa<FunctionDecl>(D))
  handleFunctionDecl(D);                     handleFunctionDecl(D);
} else if (isa<VarDecl>(D)) {              else if (isa<VarDecl>(D))
  handleVarDecl(D);                          handleVarDecl(D);
}
 
if (isa<VarDecl>(D)) {             vs.     if (isa<VarDecl>(D)) {
  for (auto *A : D.attrs()) {                for (auto *A : D.attrs())
    if (shouldProcessAttr(A)) {                if (shouldProcessAttr(A))
      handleAttr(A);                             handleAttr(A);
    }                                      }
  }
}
 
if (isa<FunctionDecl>(D)) {        vs.     if (isa<FunctionDecl>(D))
  for (auto *A : D.attrs()) {                for (auto *A : D.attrs())
    handleAttr(A);                             handleAttr(A);
  }
}
 
if (auto *D = (T)(D)) {            vs.     if (auto *D = (T)(D)) {
  if (shouldProcess(D)) {                    if (shouldProcess(D))
    handleVarDecl(D);                          handleVarDecl(D);
  } else {                                   else
    markAsIgnored(D);                          markAsIgnored(D);
  }                                        }
}
 
if (a) {                           vs.     if (a)
  b();                                       b();
} else {                                   else if (c)
  if (c) {                                   d();
    d();                                   else
  } else {                                   e();
    e();
  }
}

Version

14

Definition at line 4755 of file Format.h.

RemoveEmptyLinesInUnwrappedLines

bool clang::format::FormatStyle::RemoveEmptyLinesInUnwrappedLines

Remove empty lines within unwrapped lines.

false:                            true:
 
int c                  vs.        int c = a + b;
 
    = a + b;
 
enum : unsigned        vs.        enum : unsigned {
                                    AA = 0,
{                                   BB
  AA = 0,                         } myEnum;
  BB
} myEnum;
 
while (                vs.        while (true) {
                                  }
    true) {
}

Version

20

Definition at line 4778 of file Format.h.

RemoveParentheses

RemoveParenthesesStyle clang::format::FormatStyle::RemoveParentheses

Remove redundant parentheses.

Warning

Setting this option to any value other than Leave could lead to incorrect code formatting due to clang-format's lack of complete semantic information. As such, extra care should be taken to review code changes made by this option. \endwarning

Version

17

Definition at line 4814 of file Format.h.

RemoveSemicolon

bool clang::format::FormatStyle::RemoveSemicolon

Remove semicolons after the closing braces of functions and constructors/destructors.

Warning

Setting this option to true could lead to incorrect code formatting due to clang-format's lack of complete semantic information. As such, extra care should be taken to review code changes made by this option. \endwarning

false:                                     true:
 
int max(int a, int b) {                    int max(int a, int b) {
  return a > b ? a : b;                      return a > b ? a : b;
};                                         }

Version

16

Definition at line 4832 of file Format.h.

RequiresClausePosition

RequiresClausePositionStyle clang::format::FormatStyle::RequiresClausePosition

The position of the requires clause.

Version

15

Definition at line 4935 of file Format.h.

RequiresExpressionIndentation

RequiresExpressionIndentationKind clang::format::FormatStyle::RequiresExpressionIndentation

The indentation used for requires expression bodies.

Version

16

Definition at line 4961 of file Format.h.

SeparateDefinitionBlocks

SeparateDefinitionStyle clang::format::FormatStyle::SeparateDefinitionBlocks

Specifies the use of empty lines to separate definition blocks, including classes, structs, enums, and functions.

Never                  v.s.     Always
#include <cstring>              #include <cstring>
struct Foo {
  int a, b, c;                  struct Foo {
};                                int a, b, c;
namespace Ns {                  };
class Bar {
public:                         namespace Ns {
  struct Foobar {               class Bar {
    int a;                      public:
    int b;                        struct Foobar {
  };                                int a;
private:                            int b;
  int t;                          };
  int method1() {
    // ...                      private:
  }                               int t;
  enum List {
    ITEM1,                        int method1() {
    ITEM2                           // ...
  };                              }
  template<typename T>
  int method2(T x) {              enum List {
    // ...                          ITEM1,
  }                                 ITEM2
  int i, j, k;                    };
  int method3(int par) {
    // ...                        template<typename T>
  }                               int method2(T x) {
};                                  // ...
class C {};                       }
}
                                  int i, j, k;
 
                                  int method3(int par) {
                                    // ...
                                  }
                                };
 
                                class C {};
                                }

Version

14

Definition at line 5019 of file Format.h.

ShortNamespaceLines

unsigned clang::format::FormatStyle::ShortNamespaceLines

The maximal number of unwrapped lines that a short namespace spans.

Defaults to 1.

This determines the maximum length of short namespaces by counting unwrapped lines (i.e. containing neither opening nor closing namespace brace) and makes FixNamespaceComments omit adding end comments for those.

ShortNamespaceLines: 1     vs.     ShortNamespaceLines: 0
namespace a {                      namespace a {
  int foo;                           int foo;
}                                  } // namespace a
 
ShortNamespaceLines: 1     vs.     ShortNamespaceLines: 0
namespace b {                      namespace b {
  int foo;                           int foo;
  int bar;                           int bar;
} // namespace b                   } // namespace b

Version

13

Definition at line 5041 of file Format.h.

SkipMacroDefinitionBody

bool clang::format::FormatStyle::SkipMacroDefinitionBody

Do not format macro definition body.

Version

18

Definition at line 5045 of file Format.h.

SortIncludes

SortIncludesOptions clang::format::FormatStyle::SortIncludes

Controls if and how clang-format will sort #includes.

Version

3.8

Definition at line 5093 of file Format.h.

SortJavaStaticImport

SortJavaStaticImportOptions clang::format::FormatStyle::SortJavaStaticImport

When sorting Java imports, by default static imports are placed before non-static imports.

If JavaStaticImportAfterImport is After, static imports are placed after non-static imports.

Version

12

Definition at line 5117 of file Format.h.

SortUsingDeclarations

SortUsingDeclarationsOptions clang::format::FormatStyle::SortUsingDeclarations

Controls if and how clang-format will sort using declarations.

Version

5

Definition at line 5161 of file Format.h.

SpaceAfterCStyleCast

bool clang::format::FormatStyle::SpaceAfterCStyleCast

If true, a space is inserted after C style casts.

true:                                  false:
(int) i;                       vs.     (int)i;

Version

3.5

Definition at line 5169 of file Format.h.

SpaceAfterLogicalNot

bool clang::format::FormatStyle::SpaceAfterLogicalNot

If true, a space is inserted after the logical not operator (!).

true:                                  false:
! someExpression();            vs.     !someExpression();

Version

9

Definition at line 5177 of file Format.h.

SpaceAfterOperatorKeyword

bool clang::format::FormatStyle::SpaceAfterOperatorKeyword

If true, a space will be inserted after the operator keyword.

true:                                false:
bool operator ==(int a);     vs.     bool operator==(int a);

Version

21

Definition at line 5185 of file Format.h.

SpaceAfterTemplateKeyword

bool clang::format::FormatStyle::SpaceAfterTemplateKeyword

If true, a space will be inserted after the template keyword.

true:                                  false:
template <int> void foo();     vs.     template<int> void foo();

Version

4

Definition at line 5193 of file Format.h.

SpaceAroundPointerQualifiers

SpaceAroundPointerQualifiersStyle clang::format::FormatStyle::SpaceAroundPointerQualifiers

Defines in which cases to put a space before or after pointer qualifiers.

Version

12

Definition at line 5226 of file Format.h.

SpaceBeforeAssignmentOperators

bool clang::format::FormatStyle::SpaceBeforeAssignmentOperators

If false, spaces will be removed before assignment operators.

true:                                  false:
int a = 5;                     vs.     int a= 5;
a += 42;                               a+= 42;

Version

3.7

Definition at line 5235 of file Format.h.

SpaceBeforeCaseColon

bool clang::format::FormatStyle::SpaceBeforeCaseColon

If false, spaces will be removed before case colon.

true:                                   false
switch (x) {                    vs.     switch (x) {
  case 1 : break;                         case 1: break;
}                                       }

Version

12

Definition at line 5245 of file Format.h.

SpaceBeforeCpp11BracedList

bool clang::format::FormatStyle::SpaceBeforeCpp11BracedList

If true, a space will be inserted before a C++11 braced list used to initialize an object (after the preceding identifier or type).

true:                                  false:
Foo foo { bar };               vs.     Foo foo{ bar };
Foo {};                                Foo{};
vector<int> { 1, 2, 3 };               vector<int>{ 1, 2, 3 };
new int[3] { 1, 2, 3 };                new int[3]{ 1, 2, 3 };

Version

7

Definition at line 5257 of file Format.h.

SpaceBeforeCtorInitializerColon

bool clang::format::FormatStyle::SpaceBeforeCtorInitializerColon

If false, spaces will be removed before constructor initializer colon.

true:                                  false:
Foo::Foo() : a(a) {}                   Foo::Foo(): a(a) {}

Version

7

Definition at line 5266 of file Format.h.

SpaceBeforeEnumUnderlyingTypeColon

bool clang::format::FormatStyle::SpaceBeforeEnumUnderlyingTypeColon

If false, spaces will be removed before enum underlying type colon.

true:                                  false:
enum E : int {}                        enum E: int {}

Version

23

Definition at line 5274 of file Format.h.

SpaceBeforeInheritanceColon

bool clang::format::FormatStyle::SpaceBeforeInheritanceColon

If false, spaces will be removed before inheritance colon.

true:                                  false:
class Foo : Bar {}             vs.     class Foo: Bar {}

Version

7

Definition at line 5282 of file Format.h.

SpaceBeforeJsonColon

bool clang::format::FormatStyle::SpaceBeforeJsonColon

If true, a space will be added before a JSON colon.

For other languages, e.g. JavaScript, use SpacesInContainerLiterals instead.

true:                                  false:
{                                      {
  "key" : "value"              vs.       "key": "value"
}                                      }

Version

17

Definition at line 5293 of file Format.h.

SpaceBeforeParens

SpaceBeforeParensStyle clang::format::FormatStyle::SpaceBeforeParens

Defines in which cases to put a space before opening parentheses.

Version

3.5

Definition at line 5354 of file Format.h.

SpaceBeforeParensOptions

SpaceBeforeParensCustom clang::format::FormatStyle::SpaceBeforeParensOptions

Control of individual space before parentheses.

If SpaceBeforeParens is set to Custom, use this to specify how each individual space before parentheses case should be handled. Otherwise, this is ignored.

# Example of usage:
SpaceBeforeParens: Custom
SpaceBeforeParensOptions:
  AfterControlStatements: true
  AfterFunctionDefinitionName: true

Version

14

Definition at line 5488 of file Format.h.

SpaceBeforeRangeBasedForLoopColon

bool clang::format::FormatStyle::SpaceBeforeRangeBasedForLoopColon

If false, spaces will be removed before range-based for loop colon.

true:                                  false:
for (auto v : values) {}       vs.     for(auto v: values) {}

Version

7

Definition at line 5507 of file Format.h.

SpaceBeforeSquareBrackets

bool clang::format::FormatStyle::SpaceBeforeSquareBrackets

If true, spaces will be before [.

Lambdas will not be affected. Only the first [ will get a space added.

true:                                  false:
int a [5];                    vs.      int a[5];
int a [5][5];                 vs.      int a[5][5];

Version

10

Definition at line 5498 of file Format.h.

SpaceInEmptyBraces

SpaceInEmptyBracesStyle clang::format::FormatStyle::SpaceInEmptyBraces

Specifies when to insert a space in empty braces.

Note

This option doesn't apply to initializer braces if Cpp11BracedListStyle is not Block. \endnote

Version

22

Definition at line 5547 of file Format.h.

SpacesBeforeTrailingComments

unsigned clang::format::FormatStyle::SpacesBeforeTrailingComments

If true, spaces may be inserted into ().

This option is deprecated. See InEmptyParentheses of SpacesInParensOptions.

Version

3.7 The number of spaces before trailing line comments (// - comments).

This does not affect trailing block comments (/* - comments) as those commonly have different usage patterns and a number of special cases. In the case of Verilog, it doesn't affect a comment right after the opening parenthesis in the port or parameter list in a module header, because it is probably for the port on the following line instead of the parenthesis it follows.

SpacesBeforeTrailingComments: 3
void f() {
  if (true) {   // foo1
    f();        // bar
  }             // foo
}

Version

3.7

Definition at line 5573 of file Format.h.

SpacesInAngles

SpacesInAnglesStyle clang::format::FormatStyle::SpacesInAngles

The SpacesInAnglesStyle to use for template argument lists.

Version

3.4

Definition at line 5596 of file Format.h.

SpacesInContainerLiterals

bool clang::format::FormatStyle::SpacesInContainerLiterals

If true, spaces will be inserted around if/for/switch/while conditions.

This option is deprecated. See InConditionalStatements of SpacesInParensOptions.

Version

10 If true, spaces are inserted inside container literals (e.g. ObjC and Javascript array and dict literals). For JSON, use SpaceBeforeJsonColon instead.

true:                                  false:
var arr = [ 1, 2, 3 ];         vs.     var arr = [1, 2, 3];
f({a : 1, b : 2, c : 3});              f({a: 1, b: 2, c: 3});

3.7

Definition at line 5638 of file Format.h.

SpacesInLineCommentPrefix

SpacesInLineComment clang::format::FormatStyle::SpacesInLineCommentPrefix

How many spaces are allowed at the start of a line comment.

To disable the maximum set it to -1, apart from that the maximum takes precedence over the minimum.

Minimum = 1
Maximum = -1
// One space is forced
 
//  but more spaces are possible
 
Minimum = 0
Maximum = 0
//Forces to start every comment directly after the slashes

Note that in line comment sections the relative indent of the subsequent lines is kept, that means the following:

before:                                   after:
Minimum: 1
//if (b) {                                // if (b) {
//  return true;                          //   return true;
//}                                       // }
 
Maximum: 0
/// List:                                 ///List:
///  - Foo                                /// - Foo
///    - Bar                              ///   - Bar

This option has only effect if ReflowComments is set to true.

Version

13

Definition at line 5686 of file Format.h.

SpacesInParens

SpacesInParensStyle clang::format::FormatStyle::SpacesInParens

If true, spaces will be inserted after ( and before ).

This option is deprecated. The previous behavior is preserved by using SpacesInParens with Custom and by setting all SpacesInParensOptions to true except for InCStyleCasts and InEmptyParentheses.

Version

3.7 Defines in which cases spaces will be inserted after ( and before ).

17

Definition at line 5715 of file Format.h.

SpacesInParensOptions

SpacesInParensCustom clang::format::FormatStyle::SpacesInParensOptions

Control of individual spaces in parentheses.

If SpacesInParens is set to Custom, use this to specify how each individual space in parentheses case should be handled. Otherwise, this is ignored.

# Example of usage:
SpacesInParens: Custom
SpacesInParensOptions:
  ExceptDoubleParentheses: false
  InConditionalStatements: true
  InEmptyParentheses: true

Version

17

Definition at line 5808 of file Format.h.

SpacesInSquareBrackets

bool clang::format::FormatStyle::SpacesInSquareBrackets

If true, spaces will be inserted after [ and before ].

Lambdas without arguments or unspecified size array declarations will not be affected.

true:                                  false:
int a[ 5 ];                    vs.     int a[5];
std::unique_ptr<int[]> foo() {} // Won't be affected

Version

3.7

Definition at line 5819 of file Format.h.

Standard

LanguageStandard clang::format::FormatStyle::Standard

Parse and format C++ constructs compatible with this standard.

c++03:                                 latest:
vector<set<int> > x;           vs.     vector<set<int>> x;

Version

3.7

Definition at line 5858 of file Format.h.

StatementAttributeLikeMacros

std::vector<std::string> clang::format::FormatStyle::StatementAttributeLikeMacros

Macros which are ignored in front of a statement, as if they were an attribute.

So that they are not parsed as identifier, for example for Qts emit.

AlignConsecutiveDeclarations: true
StatementAttributeLikeMacros: []
unsigned char data = 'x';
emit          signal(data); // This is parsed as variable declaration.
 
AlignConsecutiveDeclarations: true
StatementAttributeLikeMacros: [emit]
unsigned char data = 'x';
emit signal(data); // Now it's fine again.

Version

12

Definition at line 5875 of file Format.h.

StatementMacros

std::vector<std::string> clang::format::FormatStyle::StatementMacros

A vector of macros that should be interpreted as complete statements.

Typical macros are expressions and require a semicolon to be added. Sometimes this is not the case, and this allows to make clang-format aware of such cases.

For example: Q_UNUSED

Version

8

Definition at line 5885 of file Format.h.

TableGenBreakingDAGArgOperators

std::vector<std::string> clang::format::FormatStyle::TableGenBreakingDAGArgOperators

Works only when TableGenBreakInsideDAGArg is not DontBreak.

The string list needs to consist of identifiers in TableGen. If any identifier is specified, this limits the line breaks by TableGenBreakInsideDAGArg option only on DAGArg values beginning with the specified identifiers.

For example the configuration,

TableGenBreakInsideDAGArg: BreakAll
TableGenBreakingDAGArgOperators: [ins, outs]

makes the line break only occurs inside DAGArgs beginning with the specified identifiers ins and outs.

let DAGArgIns = (ins
    i32:$src1,
    i32:$src2
);
let DAGArgOtherID = (other i32:$other1, i32:$other2);
let DAGArgBang = (!cast<SomeType>("Some") i32:$src1, i32:$src2)

Version

19

Definition at line 5911 of file Format.h.

TableGenBreakInsideDAGArg

DAGArgStyle clang::format::FormatStyle::TableGenBreakInsideDAGArg

The styles of the line break inside the DAGArg in TableGen.

Version

19

Definition at line 5939 of file Format.h.

TabWidth

unsigned clang::format::FormatStyle::TabWidth

The number of columns used for tab stops.

Version

3.7

Definition at line 5943 of file Format.h.

TemplateNames

std::vector<std::string> clang::format::FormatStyle::TemplateNames

A vector of non-keyword identifiers that should be interpreted as template names.

A < after a template name is annotated as a template opener instead of a binary operator.

Version

20

Definition at line 5952 of file Format.h.

TypenameMacros

std::vector<std::string> clang::format::FormatStyle::TypenameMacros

A vector of macros that should be interpreted as type declarations instead of as function calls.

These are expected to be macros of the form:

STACK_OF(...)

In the .clang-format configuration file, this can be configured like:

TypenameMacros: [STACK_OF, LIST]

For example: OpenSSL STACK_OF, BSD LIST_ENTRY.

Version

9

Definition at line 5979 of file Format.h.

TypeNames

std::vector<std::string> clang::format::FormatStyle::TypeNames

A vector of non-keyword identifiers that should be interpreted as type names.

A *, &, or && between a type name and another non-keyword identifier is annotated as a pointer or reference token instead of a binary operator.

Version

17

Definition at line 5962 of file Format.h.

UseTab

UseTabStyle clang::format::FormatStyle::UseTab

The way to use tab characters in the resulting file.

Version

3.7

Definition at line 6004 of file Format.h.

VariableTemplates

std::vector<std::string> clang::format::FormatStyle::VariableTemplates

A vector of non-keyword identifiers that should be interpreted as variable template names.

A ) after a variable template instantiation is not annotated as the closing parenthesis of C-style cast operator.

Version

20

Definition at line 6013 of file Format.h.

VerilogBreakBetweenInstancePorts

bool clang::format::FormatStyle::VerilogBreakBetweenInstancePorts

For Verilog, put each port on its own line in module instantiations.

true:
ffnand ff1(.q(),
           .qbar(out1),
           .clear(in1),
           .preset(in2));
 
false:
ffnand ff1(.q(), .qbar(out1), .clear(in1), .preset(in2));

Version

17

Definition at line 6027 of file Format.h.

WhitespaceSensitiveMacros

std::vector<std::string> clang::format::FormatStyle::WhitespaceSensitiveMacros

A vector of macros which are whitespace-sensitive and should not be touched.

These are expected to be macros of the form:

STRINGIZE(...)

In the .clang-format configuration file, this can be configured like:

WhitespaceSensitiveMacros: [STRINGIZE, PP_STRINGIZE]

For example: BOOST_PP_STRINGIZE

Version

11

Definition at line 6044 of file Format.h.

with

and* and parameter comments ending clang::format::FormatStyle::with

Initial value:

=` before the closing `*/` are
   *  left unchanged.
   *  \version 24 */
  SpacesInBlockCommentsStyle SpacesInBlockComments

The SpacesInBlockCommentsStyle to use for ordinary block comments.

Documentation comments such as `/** ...

...

Definition at line 5617 of file Format.h.

WrapNamespaceBodyWithEmptyLines

WrapNamespaceBodyWithEmptyLinesStyle clang::format::FormatStyle::WrapNamespaceBodyWithEmptyLines

Wrap namespace body with empty lines.

Version

20

Definition at line 6077 of file Format.h.

---

The documentation for this struct was generated from the following files:

• include/clang/Format/Format.h
• lib/Format/Format.cpp