WebSVN – QNX 8.QNX8 LLVM/Clang compiler suite – Blame – /llvm-build/x86_64/include/clang/Format/Format.h

Rev	Author	Line No.	Line
14	pmbaty	1	//===--- Format.h - Format C++ code ------------------------------ C++ --===//
		2	//
		3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
		4	// See https://llvm.org/LICENSE.txt for license information.
		5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
		6	//
		7	//===----------------------------------------------------------------------===//
		8	///
		9	/// \file
		10	/// Various functions to configurably format source code.
		11	///
		12	//===----------------------------------------------------------------------===//
		13
		14	#ifndef LLVM_CLANG_FORMAT_FORMAT_H
		15	#define LLVM_CLANG_FORMAT_FORMAT_H
		16
		17	#include "clang/Basic/LangOptions.h"
		18	#include "clang/Tooling/Core/Replacement.h"
		19	#include "clang/Tooling/Inclusions/IncludeStyle.h"
		20	#include "llvm/ADT/ArrayRef.h"
		21	#include "llvm/Support/Regex.h"
		22	#include "llvm/Support/SourceMgr.h"
		23	#include <optional>
		24	#include <system_error>
		25
		26	namespace llvm {
		27	namespace vfs {
		28	class FileSystem;
		29	}
		30	} // namespace llvm
		31
		32	namespace clang {
		33	namespace format {
		34
		35	enum class ParseError {
		36	Success = 0,
		37	Error,
		38	Unsuitable,
		39	BinPackTrailingCommaConflict,
		40	InvalidQualifierSpecified,
		41	DuplicateQualifierSpecified,
		42	MissingQualifierType,
		43	MissingQualifierOrder
		44	};
		45	class ParseErrorCategory final : public std::error_category {
		46	public:
		47	const char *name() const noexcept override;
		48	std::string message(int EV) const override;
		49	};
		50	const std::error_category &getParseCategory();
		51	std::error_code make_error_code(ParseError e);
		52
		53	/// The ``FormatStyle`` is used to configure the formatting to follow
		54	/// specific guidelines.
		55	struct FormatStyle {
		56	// If the BasedOn: was InheritParentConfig and this style needs the file from
		57	// the parent directories. It is not part of the actual style for formatting.
		58	// Thus the // instead of ///.
		59	bool InheritsParentConfig;
		60
		61	/// The extra indent or outdent of access modifiers, e.g. ``public:``.
		62	/// \version 3.3
		63	int AccessModifierOffset;
		64
		65	/// Different styles for aligning after open brackets.
		66	enum BracketAlignmentStyle : int8_t {
		67	/// Align parameters on the open bracket, e.g.:
		68	/// \code
		69	/// someLongFunction(argument1,
		70	/// argument2);
		71	/// \endcode
		72	BAS_Align,
		73	/// Don't align, instead use ``ContinuationIndentWidth``, e.g.:
		74	/// \code
		75	/// someLongFunction(argument1,
		76	/// argument2);
		77	/// \endcode
		78	BAS_DontAlign,
		79	/// Always break after an open bracket, if the parameters don't fit
		80	/// on a single line, e.g.:
		81	/// \code
		82	/// someLongFunction(
		83	/// argument1, argument2);
		84	/// \endcode
		85	BAS_AlwaysBreak,
		86	/// Always break after an open bracket, if the parameters don't fit
		87	/// on a single line. Closing brackets will be placed on a new line.
		88	/// E.g.:
		89	/// \code
		90	/// someLongFunction(
		91	/// argument1, argument2
		92	/// )
		93	/// \endcode
		94	///
		95	/// \warning
		96	/// Note: This currently only applies to parentheses.
		97	/// \endwarning
		98	BAS_BlockIndent,
		99	};
		100
		101	/// If ``true``, horizontally aligns arguments after an open bracket.
		102	///
		103	/// This applies to round brackets (parentheses), angle brackets and square
		104	/// brackets.
		105	/// \version 3.8
		106	BracketAlignmentStyle AlignAfterOpenBracket;
		107
		108	/// Different style for aligning array initializers.
		109	enum ArrayInitializerAlignmentStyle : int8_t {
		110	/// Align array column and left justify the columns e.g.:
		111	/// \code
		112	/// struct test demo[] =
		113	/// {
		114	/// {56, 23, "hello"},
		115	/// {-1, 93463, "world"},
		116	/// {7, 5, "!!" }
		117	/// };
		118	/// \endcode
		119	AIAS_Left,
		120	/// Align array column and right justify the columns e.g.:
		121	/// \code
		122	/// struct test demo[] =
		123	/// {
		124	/// {56, 23, "hello"},
		125	/// {-1, 93463, "world"},
		126	/// { 7, 5, "!!"}
		127	/// };
		128	/// \endcode
		129	AIAS_Right,
		130	/// Don't align array initializer columns.
		131	AIAS_None
		132	};
		133	/// if not ``None``, when using initialization for an array of structs
		134	/// aligns the fields into columns.
		135	///
		136	/// NOTE: As of clang-format 15 this option only applied to arrays with equal
		137	/// number of columns per row.
		138	///
		139	/// \version 13
		140	ArrayInitializerAlignmentStyle AlignArrayOfStructures;
		141
		142	/// Alignment options.
		143	///
		144	/// They can also be read as a whole for compatibility. The choices are:
		145	/// - None
		146	/// - Consecutive
		147	/// - AcrossEmptyLines
		148	/// - AcrossComments
		149	/// - AcrossEmptyLinesAndComments
		150	///
		151	/// For example, to align across empty lines and not across comments, either
		152	/// of these work.
		153	/// \code
		154	/// AlignConsecutiveMacros: AcrossEmptyLines
		155	///
		156	/// AlignConsecutiveMacros:
		157	/// Enabled: true
		158	/// AcrossEmptyLines: true
		159	/// AcrossComments: false
		160	/// \endcode
		161	struct AlignConsecutiveStyle {
		162	/// Whether aligning is enabled.
		163	/// \code
		164	/// #define SHORT_NAME 42
		165	/// #define LONGER_NAME 0x007f
		166	/// #define EVEN_LONGER_NAME (2)
		167	/// #define foo(x) (x * x)
		168	/// #define bar(y, z) (y + z)
		169	///
		170	/// int a = 1;
		171	/// int somelongname = 2;
		172	/// double c = 3;
		173	///
		174	/// int aaaa : 1;
		175	/// int b : 12;
		176	/// int ccc : 8;
		177	///
		178	/// int aaaa = 12;
		179	/// float b = 23;
		180	/// std::string ccc;
		181	/// \endcode
		182	bool Enabled;
		183	/// Whether to align across empty lines.
		184	/// \code
		185	/// true:
		186	/// int a = 1;
		187	/// int somelongname = 2;
		188	/// double c = 3;
		189	///
		190	/// int d = 3;
		191	///
		192	/// false:
		193	/// int a = 1;
		194	/// int somelongname = 2;
		195	/// double c = 3;
		196	///
		197	/// int d = 3;
		198	/// \endcode
		199	bool AcrossEmptyLines;
		200	/// Whether to align across comments.
		201	/// \code
		202	/// true:
		203	/// int d = 3;
		204	/// /* A comment. */
		205	/// double e = 4;
		206	///
		207	/// false:
		208	/// int d = 3;
		209	/// /* A comment. */
		210	/// double e = 4;
		211	/// \endcode
		212	bool AcrossComments;
		213	/// Only for ``AlignConsecutiveAssignments``. Whether compound assignments
		214	/// like ``+=`` are aligned along with ``=``.
		215	/// \code
		216	/// true:
		217	/// a &= 2;
		218	/// bbb = 2;
		219	///
		220	/// false:
		221	/// a &= 2;
		222	/// bbb = 2;
		223	/// \endcode
		224	bool AlignCompound;
		225	/// Only for ``AlignConsecutiveAssignments``. Whether short assignment
		226	/// operators are left-padded to the same length as long ones in order to
		227	/// put all assignment operators to the right of the left hand side.
		228	/// \code
		229	/// true:
		230	/// a >>= 2;
		231	/// bbb = 2;
		232	///
		233	/// a = 2;
		234	/// bbb >>= 2;
		235	///
		236	/// false:
		237	/// a >>= 2;
		238	/// bbb = 2;
		239	///
		240	/// a = 2;
		241	/// bbb >>= 2;
		242	/// \endcode
		243	bool PadOperators;
		244	bool operator==(const AlignConsecutiveStyle &R) const {
		245	return Enabled == R.Enabled && AcrossEmptyLines == R.AcrossEmptyLines &&
		246	AcrossComments == R.AcrossComments &&
		247	AlignCompound == R.AlignCompound && PadOperators == R.PadOperators;
		248	}
		249	bool operator!=(const AlignConsecutiveStyle &R) const {
		250	return !(*this == R);
		251	}
		252	};
		253
		254	/// Style of aligning consecutive macro definitions.
		255	///
		256	/// ``Consecutive`` will result in formattings like:
		257	/// \code
		258	/// #define SHORT_NAME 42
		259	/// #define LONGER_NAME 0x007f
		260	/// #define EVEN_LONGER_NAME (2)
		261	/// #define foo(x) (x * x)
		262	/// #define bar(y, z) (y + z)
		263	/// \endcode
		264	/// \version 9
		265	AlignConsecutiveStyle AlignConsecutiveMacros;
		266	/// Style of aligning consecutive assignments.
		267	///
		268	/// ``Consecutive`` will result in formattings like:
		269	/// \code
		270	/// int a = 1;
		271	/// int somelongname = 2;
		272	/// double c = 3;
		273	/// \endcode
		274	/// \version 3.8
		275	AlignConsecutiveStyle AlignConsecutiveAssignments;
		276	/// Style of aligning consecutive bit fields.
		277	///
		278	/// ``Consecutive`` will align the bitfield separators of consecutive lines.
		279	/// This will result in formattings like:
		280	/// \code
		281	/// int aaaa : 1;
		282	/// int b : 12;
		283	/// int ccc : 8;
		284	/// \endcode
		285	/// \version 11
		286	AlignConsecutiveStyle AlignConsecutiveBitFields;
		287	/// Style of aligning consecutive declarations.
		288	///
		289	/// ``Consecutive`` will align the declaration names of consecutive lines.
		290	/// This will result in formattings like:
		291	/// \code
		292	/// int aaaa = 12;
		293	/// float b = 23;
		294	/// std::string ccc;
		295	/// \endcode
		296	/// \version 3.8
		297	AlignConsecutiveStyle AlignConsecutiveDeclarations;
		298
		299	/// Different styles for aligning escaped newlines.
		300	enum EscapedNewlineAlignmentStyle : int8_t {
		301	/// Don't align escaped newlines.
		302	/// \code
		303	/// #define A \
		304	/// int aaaa; \
		305	/// int b; \
		306	/// int dddddddddd;
		307	/// \endcode
		308	ENAS_DontAlign,
		309	/// Align escaped newlines as far left as possible.
		310	/// \code
		311	/// true:
		312	/// #define A \
		313	/// int aaaa; \
		314	/// int b; \
		315	/// int dddddddddd;
		316	///
		317	/// false:
		318	/// \endcode
		319	ENAS_Left,
		320	/// Align escaped newlines in the right-most column.
		321	/// \code
		322	/// #define A \
		323	/// int aaaa; \
		324	/// int b; \
		325	/// int dddddddddd;
		326	/// \endcode
		327	ENAS_Right,
		328	};
		329
		330	/// Options for aligning backslashes in escaped newlines.
		331	/// \version 5
		332	EscapedNewlineAlignmentStyle AlignEscapedNewlines;
		333
		334	/// Different styles for aligning operands.
		335	enum OperandAlignmentStyle : int8_t {
		336	/// Do not align operands of binary and ternary expressions.
		337	/// The wrapped lines are indented ``ContinuationIndentWidth`` spaces from
		338	/// the start of the line.
		339	OAS_DontAlign,
		340	/// Horizontally align operands of binary and ternary expressions.
		341	///
		342	/// Specifically, this aligns operands of a single expression that needs
		343	/// to be split over multiple lines, e.g.:
		344	/// \code
		345	/// int aaa = bbbbbbbbbbbbbbb +
		346	/// ccccccccccccccc;
		347	/// \endcode
		348	///
		349	/// When ``BreakBeforeBinaryOperators`` is set, the wrapped operator is
		350	/// aligned with the operand on the first line.
		351	/// \code
		352	/// int aaa = bbbbbbbbbbbbbbb
		353	/// + ccccccccccccccc;
		354	/// \endcode
		355	OAS_Align,
		356	/// Horizontally align operands of binary and ternary expressions.
		357	///
		358	/// This is similar to ``AO_Align``, except when
		359	/// ``BreakBeforeBinaryOperators`` is set, the operator is un-indented so
		360	/// that the wrapped operand is aligned with the operand on the first line.
		361	/// \code
		362	/// int aaa = bbbbbbbbbbbbbbb
		363	/// + ccccccccccccccc;
		364	/// \endcode
		365	OAS_AlignAfterOperator,
		366	};
		367
		368	/// If ``true``, horizontally align operands of binary and ternary
		369	/// expressions.
		370	/// \version 3.5
		371	OperandAlignmentStyle AlignOperands;
		372
		373	/// Enums for AlignTrailingComments
		374	enum TrailingCommentsAlignmentKinds : int8_t {
		375	/// Leave trailing comments as they are.
		376	/// \code
		377	/// int a; // comment
		378	/// int ab; // comment
		379	///
		380	/// int abc; // comment
		381	/// int abcd; // comment
		382	/// \endcode
		383	TCAS_Leave,
		384	/// Align trailing comments.
		385	/// \code
		386	/// int a; // comment
		387	/// int ab; // comment
		388	///
		389	/// int abc; // comment
		390	/// int abcd; // comment
		391	/// \endcode
		392	TCAS_Always,
		393	/// Don't align trailing comments but other formatter applies.
		394	/// \code
		395	/// int a; // comment
		396	/// int ab; // comment
		397	///
		398	/// int abc; // comment
		399	/// int abcd; // comment
		400	/// \endcode
		401	TCAS_Never,
		402	};
		403
		404	/// Alignment options
		405	struct TrailingCommentsAlignmentStyle {
		406	/// Specifies the way to align trailing comments.
		407	TrailingCommentsAlignmentKinds Kind;
		408	/// How many empty lines to apply alignment.
		409	/// When both ``MaxEmptyLinesToKeep`` and ``OverEmptyLines`` are set to 2,
		410	/// it formats like below.
		411	/// \code
		412	/// int a; // all these
		413	///
		414	/// int ab; // comments are
		415	///
		416	///
		417	/// int abcdef; // aligned
		418	/// \endcode
		419	///
		420	/// When ``MaxEmptyLinesToKeep`` is set to 2 and ``OverEmptyLines`` is set
		421	/// to 1, it formats like below.
		422	/// \code
		423	/// int a; // these are
		424	///
		425	/// int ab; // aligned
		426	///
		427	///
		428	/// int abcdef; // but this isn't
		429	/// \endcode
		430	unsigned OverEmptyLines;
		431
		432	bool operator==(const TrailingCommentsAlignmentStyle &R) const {
		433	return Kind == R.Kind && OverEmptyLines == R.OverEmptyLines;
		434	}
		435	bool operator!=(const TrailingCommentsAlignmentStyle &R) const {
		436	return !(*this == R);
		437	}
		438	};
		439
		440	/// Control of trailing comments.
		441	///
		442	/// NOTE: As of clang-format 16 this option is not a bool but can be set
		443	/// to the options. Conventional bool options still can be parsed as before.
		444	///
		445	/// \code{.yaml}
		446	/// # Example of usage:
		447	/// AlignTrailingComments:
		448	/// Kind: Always
		449	/// OverEmptyLines: 2
		450	/// \endcode
		451	/// \version 3.7
		452	TrailingCommentsAlignmentStyle AlignTrailingComments;
		453
		454	/// \brief If a function call or braced initializer list doesn't fit on a
		455	/// line, allow putting all arguments onto the next line, even if
		456	/// ``BinPackArguments`` is ``false``.
		457	/// \code
		458	/// true:
		459	/// callFunction(
		460	/// a, b, c, d);
		461	///
		462	/// false:
		463	/// callFunction(a,
		464	/// b,
		465	/// c,
		466	/// d);
		467	/// \endcode
		468	/// \version 9
		469	bool AllowAllArgumentsOnNextLine;
		470
		471	/// This option is deprecated. See ``NextLine`` of
		472	/// ``PackConstructorInitializers``.
		473	/// \version 9
		474	// bool AllowAllConstructorInitializersOnNextLine;
		475
		476	/// If the function declaration doesn't fit on a line,
		477	/// allow putting all parameters of a function declaration onto
		478	/// the next line even if ``BinPackParameters`` is ``false``.
		479	/// \code
		480	/// true:
		481	/// void myFunction(
		482	/// int a, int b, int c, int d, int e);
		483	///
		484	/// false:
		485	/// void myFunction(int a,
		486	/// int b,
		487	/// int c,
		488	/// int d,
		489	/// int e);
		490	/// \endcode
		491	/// \version 3.3
		492	bool AllowAllParametersOfDeclarationOnNextLine;
		493
		494	/// Different styles for merging short blocks containing at most one
		495	/// statement.
		496	enum ShortBlockStyle : int8_t {
		497	/// Never merge blocks into a single line.
		498	/// \code
		499	/// while (true) {
		500	/// }
		501	/// while (true) {
		502	/// continue;
		503	/// }
		504	/// \endcode
		505	SBS_Never,
		506	/// Only merge empty blocks.
		507	/// \code
		508	/// while (true) {}
		509	/// while (true) {
		510	/// continue;
		511	/// }
		512	/// \endcode
		513	SBS_Empty,
		514	/// Always merge short blocks into a single line.
		515	/// \code
		516	/// while (true) {}
		517	/// while (true) { continue; }
		518	/// \endcode
		519	SBS_Always,
		520	};
		521
		522	/// Dependent on the value, ``while (true) { continue; }`` can be put on a
		523	/// single line.
		524	/// \version 3.5
		525	ShortBlockStyle AllowShortBlocksOnASingleLine;
		526
		527	/// If ``true``, short case labels will be contracted to a single line.
		528	/// \code
		529	/// true: false:
		530	/// switch (a) { vs. switch (a) {
		531	/// case 1: x = 1; break; case 1:
		532	/// case 2: return; x = 1;
		533	/// } break;
		534	/// case 2:
		535	/// return;
		536	/// }
		537	/// \endcode
		538	/// \version 3.6
		539	bool AllowShortCaseLabelsOnASingleLine;
		540
		541	/// Allow short enums on a single line.
		542	/// \code
		543	/// true:
		544	/// enum { A, B } myEnum;
		545	///
		546	/// false:
		547	/// enum {
		548	/// A,
		549	/// B
		550	/// } myEnum;
		551	/// \endcode
		552	/// \version 11
		553	bool AllowShortEnumsOnASingleLine;
		554
		555	/// Different styles for merging short functions containing at most one
		556	/// statement.
		557	enum ShortFunctionStyle : int8_t {
		558	/// Never merge functions into a single line.
		559	SFS_None,
		560	/// Only merge functions defined inside a class. Same as "inline",
		561	/// except it does not implies "empty": i.e. top level empty functions
		562	/// are not merged either.
		563	/// \code
		564	/// class Foo {
		565	/// void f() { foo(); }
		566	/// };
		567	/// void f() {
		568	/// foo();
		569	/// }
		570	/// void f() {
		571	/// }
		572	/// \endcode
		573	SFS_InlineOnly,
		574	/// Only merge empty functions.
		575	/// \code
		576	/// void f() {}
		577	/// void f2() {
		578	/// bar2();
		579	/// }
		580	/// \endcode
		581	SFS_Empty,
		582	/// Only merge functions defined inside a class. Implies "empty".
		583	/// \code
		584	/// class Foo {
		585	/// void f() { foo(); }
		586	/// };
		587	/// void f() {
		588	/// foo();
		589	/// }
		590	/// void f() {}
		591	/// \endcode
		592	SFS_Inline,
		593	/// Merge all functions fitting on a single line.
		594	/// \code
		595	/// class Foo {
		596	/// void f() { foo(); }
		597	/// };
		598	/// void f() { bar(); }
		599	/// \endcode
		600	SFS_All,
		601	};
		602
		603	/// Dependent on the value, ``int f() { return 0; }`` can be put on a
		604	/// single line.
		605	/// \version 3.5
		606	ShortFunctionStyle AllowShortFunctionsOnASingleLine;
		607
		608	/// Different styles for handling short if statements.
		609	enum ShortIfStyle : int8_t {
		610	/// Never put short ifs on the same line.
		611	/// \code
		612	/// if (a)
		613	/// return;
		614	///
		615	/// if (b)
		616	/// return;
		617	/// else
		618	/// return;
		619	///
		620	/// if (c)
		621	/// return;
		622	/// else {
		623	/// return;
		624	/// }
		625	/// \endcode
		626	SIS_Never,
		627	/// Put short ifs on the same line only if there is no else statement.
		628	/// \code
		629	/// if (a) return;
		630	///
		631	/// if (b)
		632	/// return;
		633	/// else
		634	/// return;
		635	///
		636	/// if (c)
		637	/// return;
		638	/// else {
		639	/// return;
		640	/// }
		641	/// \endcode
		642	SIS_WithoutElse,
		643	/// Put short ifs, but not else ifs nor else statements, on the same line.
		644	/// \code
		645	/// if (a) return;
		646	///
		647	/// if (b) return;
		648	/// else if (b)
		649	/// return;
		650	/// else
		651	/// return;
		652	///
		653	/// if (c) return;
		654	/// else {
		655	/// return;
		656	/// }
		657	/// \endcode
		658	SIS_OnlyFirstIf,
		659	/// Always put short ifs, else ifs and else statements on the same
		660	/// line.
		661	/// \code
		662	/// if (a) return;
		663	///
		664	/// if (b) return;
		665	/// else return;
		666	///
		667	/// if (c) return;
		668	/// else {
		669	/// return;
		670	/// }
		671	/// \endcode
		672	SIS_AllIfsAndElse,
		673	};
		674
		675	/// Dependent on the value, ``if (a) return;`` can be put on a single line.
		676	/// \version 3.3
		677	ShortIfStyle AllowShortIfStatementsOnASingleLine;
		678
		679	/// Different styles for merging short lambdas containing at most one
		680	/// statement.
		681	enum ShortLambdaStyle : int8_t {
		682	/// Never merge lambdas into a single line.
		683	SLS_None,
		684	/// Only merge empty lambdas.
		685	/// \code
		686	/// auto lambda = [](int a) {};
		687	/// auto lambda2 = [](int a) {
		688	/// return a;
		689	/// };
		690	/// \endcode
		691	SLS_Empty,
		692	/// Merge lambda into a single line if the lambda is argument of a function.
		693	/// \code
		694	/// auto lambda = [](int x, int y) {
		695	/// return x < y;
		696	/// };
		697	/// sort(a.begin(), a.end(), [](int x, int y) { return x < y; });
		698	/// \endcode
		699	SLS_Inline,
		700	/// Merge all lambdas fitting on a single line.
		701	/// \code
		702	/// auto lambda = [](int a) {};
		703	/// auto lambda2 = [](int a) { return a; };
		704	/// \endcode
		705	SLS_All,
		706	};
		707
		708	/// Dependent on the value, ``auto lambda []() { return 0; }`` can be put on a
		709	/// single line.
		710	/// \version 9
		711	ShortLambdaStyle AllowShortLambdasOnASingleLine;
		712
		713	/// If ``true``, ``while (true) continue;`` can be put on a single
		714	/// line.
		715	/// \version 3.7
		716	bool AllowShortLoopsOnASingleLine;
		717
		718	/// Different ways to break after the function definition return type.
		719	/// This option is deprecated and is retained for backwards compatibility.
		720	enum DefinitionReturnTypeBreakingStyle : int8_t {
		721	/// Break after return type automatically.
		722	/// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
		723	DRTBS_None,
		724	/// Always break after the return type.
		725	DRTBS_All,
		726	/// Always break after the return types of top-level functions.
		727	DRTBS_TopLevel,
		728	};
		729
		730	/// Different ways to break after the function definition or
		731	/// declaration return type.
		732	enum ReturnTypeBreakingStyle : int8_t {
		733	/// Break after return type automatically.
		734	/// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
		735	/// \code
		736	/// class A {
		737	/// int f() { return 0; };
		738	/// };
		739	/// int f();
		740	/// int f() { return 1; }
		741	/// \endcode
		742	RTBS_None,
		743	/// Always break after the return type.
		744	/// \code
		745	/// class A {
		746	/// int
		747	/// f() {
		748	/// return 0;
		749	/// };
		750	/// };
		751	/// int
		752	/// f();
		753	/// int
		754	/// f() {
		755	/// return 1;
		756	/// }
		757	/// \endcode
		758	RTBS_All,
		759	/// Always break after the return types of top-level functions.
		760	/// \code
		761	/// class A {
		762	/// int f() { return 0; };
		763	/// };
		764	/// int
		765	/// f();
		766	/// int
		767	/// f() {
		768	/// return 1;
		769	/// }
		770	/// \endcode
		771	RTBS_TopLevel,
		772	/// Always break after the return type of function definitions.
		773	/// \code
		774	/// class A {
		775	/// int
		776	/// f() {
		777	/// return 0;
		778	/// };
		779	/// };
		780	/// int f();
		781	/// int
		782	/// f() {
		783	/// return 1;
		784	/// }
		785	/// \endcode
		786	RTBS_AllDefinitions,
		787	/// Always break after the return type of top-level definitions.
		788	/// \code
		789	/// class A {
		790	/// int f() { return 0; };
		791	/// };
		792	/// int f();
		793	/// int
		794	/// f() {
		795	/// return 1;
		796	/// }
		797	/// \endcode
		798	RTBS_TopLevelDefinitions,
		799	};
		800
		801	/// The function definition return type breaking style to use. This
		802	/// option is deprecated and is retained for backwards compatibility.
		803	/// \version 3.7
		804	DefinitionReturnTypeBreakingStyle AlwaysBreakAfterDefinitionReturnType;
		805
		806	/// The function declaration return type breaking style to use.
		807	/// \version 3.8
		808	ReturnTypeBreakingStyle AlwaysBreakAfterReturnType;
		809
		810	/// If ``true``, always break before multiline string literals.
		811	///
		812	/// This flag is mean to make cases where there are multiple multiline strings
		813	/// in a file look more consistent. Thus, it will only take effect if wrapping
		814	/// the string at that point leads to it being indented
		815	/// ``ContinuationIndentWidth`` spaces from the start of the line.
		816	/// \code
		817	/// true: false:
		818	/// aaaa = vs. aaaa = "bbbb"
		819	/// "bbbb" "cccc";
		820	/// "cccc";
		821	/// \endcode
		822	/// \version 3.4
		823	bool AlwaysBreakBeforeMultilineStrings;
		824
		825	/// Different ways to break after the template declaration.
		826	enum BreakTemplateDeclarationsStyle : int8_t {
		827	/// Do not force break before declaration.
		828	/// ``PenaltyBreakTemplateDeclaration`` is taken into account.
		829	/// \code
		830	/// template <typename T> T foo() {
		831	/// }
		832	/// template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa,
		833	/// int bbbbbbbbbbbbbbbbbbbbb) {
		834	/// }
		835	/// \endcode
		836	BTDS_No,
		837	/// Force break after template declaration only when the following
		838	/// declaration spans multiple lines.
		839	/// \code
		840	/// template <typename T> T foo() {
		841	/// }
		842	/// template <typename T>
		843	/// T foo(int aaaaaaaaaaaaaaaaaaaaa,
		844	/// int bbbbbbbbbbbbbbbbbbbbb) {
		845	/// }
		846	/// \endcode
		847	BTDS_MultiLine,
		848	/// Always break after template declaration.
		849	/// \code
		850	/// template <typename T>
		851	/// T foo() {
		852	/// }
		853	/// template <typename T>
		854	/// T foo(int aaaaaaaaaaaaaaaaaaaaa,
		855	/// int bbbbbbbbbbbbbbbbbbbbb) {
		856	/// }
		857	/// \endcode
		858	BTDS_Yes
		859	};
		860
		861	/// The template declaration breaking style to use.
		862	/// \version 3.4
		863	BreakTemplateDeclarationsStyle AlwaysBreakTemplateDeclarations;
		864
		865	/// A vector of strings that should be interpreted as attributes/qualifiers
		866	/// instead of identifiers. This can be useful for language extensions or
		867	/// static analyzer annotations.
		868	///
		869	/// For example:
		870	/// \code
		871	/// x = (char *__capability)&y;
		872	/// int function(void) __ununsed;
		873	/// void only_writes_to_buffer(char *__output buffer);
		874	/// \endcode
		875	///
		876	/// In the .clang-format configuration file, this can be configured like:
		877	/// \code{.yaml}
		878	/// AttributeMacros: ['__capability', '__output', '__ununsed']
		879	/// \endcode
		880	///
		881	/// \version 12
		882	std::vector<std::string> AttributeMacros;
		883
		884	/// If ``false``, a function call's arguments will either be all on the
		885	/// same line or will have one line each.
		886	/// \code
		887	/// true:
		888	/// void f() {
		889	/// f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
		890	/// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
		891	/// }
		892	///
		893	/// false:
		894	/// void f() {
		895	/// f(aaaaaaaaaaaaaaaaaaaa,
		896	/// aaaaaaaaaaaaaaaaaaaa,
		897	/// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
		898	/// }
		899	/// \endcode
		900	/// \version 3.7
		901	bool BinPackArguments;
		902
		903	/// If ``false``, a function declaration's or function definition's
		904	/// parameters will either all be on the same line or will have one line each.
		905	/// \code
		906	/// true:
		907	/// void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
		908	/// int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
		909	///
		910	/// false:
		911	/// void f(int aaaaaaaaaaaaaaaaaaaa,
		912	/// int aaaaaaaaaaaaaaaaaaaa,
		913	/// int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
		914	/// \endcode
		915	/// \version 3.7
		916	bool BinPackParameters;
		917
		918	/// Styles for adding spacing around ``:`` in bitfield definitions.
		919	enum BitFieldColonSpacingStyle : int8_t {
		920	/// Add one space on each side of the ``:``
		921	/// \code
		922	/// unsigned bf : 2;
		923	/// \endcode
		924	BFCS_Both,
		925	/// Add no space around the ``:`` (except when needed for
		926	/// ``AlignConsecutiveBitFields``).
		927	/// \code
		928	/// unsigned bf:2;
		929	/// \endcode
		930	BFCS_None,
		931	/// Add space before the ``:`` only
		932	/// \code
		933	/// unsigned bf :2;
		934	/// \endcode
		935	BFCS_Before,
		936	/// Add space after the ``:`` only (space may be added before if
		937	/// needed for ``AlignConsecutiveBitFields``).
		938	/// \code
		939	/// unsigned bf: 2;
		940	/// \endcode
		941	BFCS_After
		942	};
		943	/// The BitFieldColonSpacingStyle to use for bitfields.
		944	/// \version 12
		945	BitFieldColonSpacingStyle BitFieldColonSpacing;
		946
		947	/// Different ways to wrap braces after control statements.
		948	enum BraceWrappingAfterControlStatementStyle : int8_t {
		949	/// Never wrap braces after a control statement.
		950	/// \code
		951	/// if (foo()) {
		952	/// } else {
		953	/// }
		954	/// for (int i = 0; i < 10; ++i) {
		955	/// }
		956	/// \endcode
		957	BWACS_Never,
		958	/// Only wrap braces after a multi-line control statement.
		959	/// \code
		960	/// if (foo && bar &&
		961	/// baz)
		962	/// {
		963	/// quux();
		964	/// }
		965	/// while (foo \|\| bar) {
		966	/// }
		967	/// \endcode
		968	BWACS_MultiLine,
		969	/// Always wrap braces after a control statement.
		970	/// \code
		971	/// if (foo())
		972	/// {
		973	/// } else
		974	/// {}
		975	/// for (int i = 0; i < 10; ++i)
		976	/// {}
		977	/// \endcode
		978	BWACS_Always
		979	};
		980
		981	/// Precise control over the wrapping of braces.
		982	/// \code
		983	/// # Should be declared this way:
		984	/// BreakBeforeBraces: Custom
		985	/// BraceWrapping:
		986	/// AfterClass: true
		987	/// \endcode
		988	struct BraceWrappingFlags {
		989	/// Wrap case labels.
		990	/// \code
		991	/// false: true:
		992	/// switch (foo) { vs. switch (foo) {
		993	/// case 1: { case 1:
		994	/// bar(); {
		995	/// break; bar();
		996	/// } break;
		997	/// default: { }
		998	/// plop(); default:
		999	/// } {
		1000	/// } plop();
		1001	/// }
		1002	/// }
		1003	/// \endcode
		1004	bool AfterCaseLabel;
		1005	/// Wrap class definitions.
		1006	/// \code
		1007	/// true:
		1008	/// class foo
		1009	/// {};
		1010	///
		1011	/// false:
		1012	/// class foo {};
		1013	/// \endcode
		1014	bool AfterClass;
		1015
		1016	/// Wrap control statements (``if``/``for``/``while``/``switch``/..).
		1017	BraceWrappingAfterControlStatementStyle AfterControlStatement;
		1018	/// Wrap enum definitions.
		1019	/// \code
		1020	/// true:
		1021	/// enum X : int
		1022	/// {
		1023	/// B
		1024	/// };
		1025	///
		1026	/// false:
		1027	/// enum X : int { B };
		1028	/// \endcode
		1029	bool AfterEnum;
		1030	/// Wrap function definitions.
		1031	/// \code
		1032	/// true:
		1033	/// void foo()
		1034	/// {
		1035	/// bar();
		1036	/// bar2();
		1037	/// }
		1038	///
		1039	/// false:
		1040	/// void foo() {
		1041	/// bar();
		1042	/// bar2();
		1043	/// }
		1044	/// \endcode
		1045	bool AfterFunction;
		1046	/// Wrap namespace definitions.
		1047	/// \code
		1048	/// true:
		1049	/// namespace
		1050	/// {
		1051	/// int foo();
		1052	/// int bar();
		1053	/// }
		1054	///
		1055	/// false:
		1056	/// namespace {
		1057	/// int foo();
		1058	/// int bar();
		1059	/// }
		1060	/// \endcode
		1061	bool AfterNamespace;
		1062	/// Wrap ObjC definitions (interfaces, implementations...).
		1063	/// \note @autoreleasepool and @synchronized blocks are wrapped
		1064	/// according to `AfterControlStatement` flag.
		1065	bool AfterObjCDeclaration;
		1066	/// Wrap struct definitions.
		1067	/// \code
		1068	/// true:
		1069	/// struct foo
		1070	/// {
		1071	/// int x;
		1072	/// };
		1073	///
		1074	/// false:
		1075	/// struct foo {
		1076	/// int x;
		1077	/// };
		1078	/// \endcode
		1079	bool AfterStruct;
		1080	/// Wrap union definitions.
		1081	/// \code
		1082	/// true:
		1083	/// union foo
		1084	/// {
		1085	/// int x;
		1086	/// }
		1087	///
		1088	/// false:
		1089	/// union foo {
		1090	/// int x;
		1091	/// }
		1092	/// \endcode
		1093	bool AfterUnion;
		1094	/// Wrap extern blocks.
		1095	/// \code
		1096	/// true:
		1097	/// extern "C"
		1098	/// {
		1099	/// int foo();
		1100	/// }
		1101	///
		1102	/// false:
		1103	/// extern "C" {
		1104	/// int foo();
		1105	/// }
		1106	/// \endcode
		1107	bool AfterExternBlock; // Partially superseded by IndentExternBlock
		1108	/// Wrap before ``catch``.
		1109	/// \code
		1110	/// true:
		1111	/// try {
		1112	/// foo();
		1113	/// }
		1114	/// catch () {
		1115	/// }
		1116	///
		1117	/// false:
		1118	/// try {
		1119	/// foo();
		1120	/// } catch () {
		1121	/// }
		1122	/// \endcode
		1123	bool BeforeCatch;
		1124	/// Wrap before ``else``.
		1125	/// \code
		1126	/// true:
		1127	/// if (foo()) {
		1128	/// }
		1129	/// else {
		1130	/// }
		1131	///
		1132	/// false:
		1133	/// if (foo()) {
		1134	/// } else {
		1135	/// }
		1136	/// \endcode
		1137	bool BeforeElse;
		1138	/// Wrap lambda block.
		1139	/// \code
		1140	/// true:
		1141	/// connect(
		1142	/// []()
		1143	/// {
		1144	/// foo();
		1145	/// bar();
		1146	/// });
		1147	///
		1148	/// false:
		1149	/// connect([]() {
		1150	/// foo();
		1151	/// bar();
		1152	/// });
		1153	/// \endcode
		1154	bool BeforeLambdaBody;
		1155	/// Wrap before ``while``.
		1156	/// \code
		1157	/// true:
		1158	/// do {
		1159	/// foo();
		1160	/// }
		1161	/// while (1);
		1162	///
		1163	/// false:
		1164	/// do {
		1165	/// foo();
		1166	/// } while (1);
		1167	/// \endcode
		1168	bool BeforeWhile;
		1169	/// Indent the wrapped braces themselves.
		1170	bool IndentBraces;
		1171	/// If ``false``, empty function body can be put on a single line.
		1172	/// This option is used only if the opening brace of the function has
		1173	/// already been wrapped, i.e. the `AfterFunction` brace wrapping mode is
		1174	/// set, and the function could/should not be put on a single line (as per
		1175	/// `AllowShortFunctionsOnASingleLine` and constructor formatting options).
		1176	/// \code
		1177	/// false: true:
		1178	/// int f() vs. int f()
		1179	/// {} {
		1180	/// }
		1181	/// \endcode
		1182	///
		1183	bool SplitEmptyFunction;
		1184	/// If ``false``, empty record (e.g. class, struct or union) body
		1185	/// can be put on a single line. This option is used only if the opening
		1186	/// brace of the record has already been wrapped, i.e. the `AfterClass`
		1187	/// (for classes) brace wrapping mode is set.
		1188	/// \code
		1189	/// false: true:
		1190	/// class Foo vs. class Foo
		1191	/// {} {
		1192	/// }
		1193	/// \endcode
		1194	///
		1195	bool SplitEmptyRecord;
		1196	/// If ``false``, empty namespace body can be put on a single line.
		1197	/// This option is used only if the opening brace of the namespace has
		1198	/// already been wrapped, i.e. the `AfterNamespace` brace wrapping mode is
		1199	/// set.
		1200	/// \code
		1201	/// false: true:
		1202	/// namespace Foo vs. namespace Foo
		1203	/// {} {
		1204	/// }
		1205	/// \endcode
		1206	///
		1207	bool SplitEmptyNamespace;
		1208	};
		1209
		1210	/// Control of individual brace wrapping cases.
		1211	///
		1212	/// If ``BreakBeforeBraces`` is set to ``BS_Custom``, use this to specify how
		1213	/// each individual brace case should be handled. Otherwise, this is ignored.
		1214	/// \code{.yaml}
		1215	/// # Example of usage:
		1216	/// BreakBeforeBraces: Custom
		1217	/// BraceWrapping:
		1218	/// AfterEnum: true
		1219	/// AfterStruct: false
		1220	/// SplitEmptyFunction: false
		1221	/// \endcode
		1222	/// \version 3.8
		1223	BraceWrappingFlags BraceWrapping;
		1224
		1225	/// Different ways to break after attributes.
		1226	enum AttributeBreakingStyle : int8_t {
		1227	/// Always break after attributes.
		1228	/// \code
		1229	/// [[nodiscard]]
		1230	/// inline int f();
		1231	/// [[gnu::const]] [[nodiscard]]
		1232	/// int g();
		1233	/// \endcode
		1234	ABS_Always,
		1235	/// Leave the line breaking after attributes as is.
		1236	/// \code
		1237	/// [[nodiscard]] inline int f();
		1238	/// [[gnu::const]] [[nodiscard]]
		1239	/// int g();
		1240	/// \endcode
		1241	ABS_Leave,
		1242	/// Never break after attributes.
		1243	/// \code
		1244	/// [[nodiscard]] inline int f();
		1245	/// [[gnu::const]] [[nodiscard]] int g();
		1246	/// \endcode
		1247	ABS_Never,
		1248	};
		1249
		1250	/// Break after a group of C++11 attributes before a function
		1251	/// declaration/definition name.
		1252	/// \version 16
		1253	AttributeBreakingStyle BreakAfterAttributes;
		1254
		1255	/// If ``true``, clang-format will always break after a Json array `[`
		1256	/// otherwise it will scan until the closing `]` to determine if it should add
		1257	/// newlines between elements (prettier compatible).
		1258	///
		1259	/// NOTE: This is currently only for formatting JSON.
		1260	/// \code
		1261	/// true: false:
		1262	/// [ vs. [1, 2, 3, 4]
		1263	/// 1,
		1264	/// 2,
		1265	/// 3,
		1266	/// 4
		1267	/// ]
		1268	/// \endcode
		1269	/// \version 16
		1270	bool BreakArrays;
		1271
		1272	/// The style of wrapping parameters on the same line (bin-packed) or
		1273	/// on one line each.
		1274	enum BinPackStyle : int8_t {
		1275	/// Automatically determine parameter bin-packing behavior.
		1276	BPS_Auto,
		1277	/// Always bin-pack parameters.
		1278	BPS_Always,
		1279	/// Never bin-pack parameters.
		1280	BPS_Never,
		1281	};
		1282
		1283	/// The style of breaking before or after binary operators.
		1284	enum BinaryOperatorStyle : int8_t {
		1285	/// Break after operators.
		1286	/// \code
		1287	/// LooooooooooongType loooooooooooooooooooooongVariable =
		1288	/// someLooooooooooooooooongFunction();
		1289	///
		1290	/// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +
		1291	/// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==
		1292	/// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
		1293	/// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >
		1294	/// ccccccccccccccccccccccccccccccccccccccccc;
		1295	/// \endcode
		1296	BOS_None,
		1297	/// Break before operators that aren't assignments.
		1298	/// \code
		1299	/// LooooooooooongType loooooooooooooooooooooongVariable =
		1300	/// someLooooooooooooooooongFunction();
		1301	///
		1302	/// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
		1303	/// + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
		1304	/// == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
		1305	/// && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
		1306	/// > ccccccccccccccccccccccccccccccccccccccccc;
		1307	/// \endcode
		1308	BOS_NonAssignment,
		1309	/// Break before operators.
		1310	/// \code
		1311	/// LooooooooooongType loooooooooooooooooooooongVariable
		1312	/// = someLooooooooooooooooongFunction();
		1313	///
		1314	/// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
		1315	/// + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
		1316	/// == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
		1317	/// && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
		1318	/// > ccccccccccccccccccccccccccccccccccccccccc;
		1319	/// \endcode
		1320	BOS_All,
		1321	};
		1322
		1323	/// The way to wrap binary operators.
		1324	/// \version 3.6
		1325	BinaryOperatorStyle BreakBeforeBinaryOperators;
		1326
		1327	/// Different ways to attach braces to their surrounding context.
		1328	enum BraceBreakingStyle : int8_t {
		1329	/// Always attach braces to surrounding context.
		1330	/// \code
		1331	/// namespace N {
		1332	/// enum E {
		1333	/// E1,
		1334	/// E2,
		1335	/// };
		1336	///
		1337	/// class C {
		1338	/// public:
		1339	/// C();
		1340	/// };
		1341	///
		1342	/// bool baz(int i) {
		1343	/// try {
		1344	/// do {
		1345	/// switch (i) {
		1346	/// case 1: {
		1347	/// foobar();
		1348	/// break;
		1349	/// }
		1350	/// default: {
		1351	/// break;
		1352	/// }
		1353	/// }
		1354	/// } while (--i);
		1355	/// return true;
		1356	/// } catch (...) {
		1357	/// handleError();
		1358	/// return false;
		1359	/// }
		1360	/// }
		1361	///
		1362	/// void foo(bool b) {
		1363	/// if (b) {
		1364	/// baz(2);
		1365	/// } else {
		1366	/// baz(5);
		1367	/// }
		1368	/// }
		1369	///
		1370	/// void bar() { foo(true); }
		1371	/// } // namespace N
		1372	/// \endcode
		1373	BS_Attach,
		1374	/// Like ``Attach``, but break before braces on function, namespace and
		1375	/// class definitions.
		1376	/// \code
		1377	/// namespace N
		1378	/// {
		1379	/// enum E {
		1380	/// E1,
		1381	/// E2,
		1382	/// };
		1383	///
		1384	/// class C
		1385	/// {
		1386	/// public:
		1387	/// C();
		1388	/// };
		1389	///
		1390	/// bool baz(int i)
		1391	/// {
		1392	/// try {
		1393	/// do {
		1394	/// switch (i) {
		1395	/// case 1: {
		1396	/// foobar();
		1397	/// break;
		1398	/// }
		1399	/// default: {
		1400	/// break;
		1401	/// }
		1402	/// }
		1403	/// } while (--i);
		1404	/// return true;
		1405	/// } catch (...) {
		1406	/// handleError();
		1407	/// return false;
		1408	/// }
		1409	/// }
		1410	///
		1411	/// void foo(bool b)
		1412	/// {
		1413	/// if (b) {
		1414	/// baz(2);
		1415	/// } else {
		1416	/// baz(5);
		1417	/// }
		1418	/// }
		1419	///
		1420	/// void bar() { foo(true); }
		1421	/// } // namespace N
		1422	/// \endcode
		1423	BS_Linux,
		1424	/// Like ``Attach``, but break before braces on enum, function, and record
		1425	/// definitions.
		1426	/// \code
		1427	/// namespace N {
		1428	/// enum E
		1429	/// {
		1430	/// E1,
		1431	/// E2,
		1432	/// };
		1433	///
		1434	/// class C
		1435	/// {
		1436	/// public:
		1437	/// C();
		1438	/// };
		1439	///
		1440	/// bool baz(int i)
		1441	/// {
		1442	/// try {
		1443	/// do {
		1444	/// switch (i) {
		1445	/// case 1: {
		1446	/// foobar();
		1447	/// break;
		1448	/// }
		1449	/// default: {
		1450	/// break;
		1451	/// }
		1452	/// }
		1453	/// } while (--i);
		1454	/// return true;
		1455	/// } catch (...) {
		1456	/// handleError();
		1457	/// return false;
		1458	/// }
		1459	/// }
		1460	///
		1461	/// void foo(bool b)
		1462	/// {
		1463	/// if (b) {
		1464	/// baz(2);
		1465	/// } else {
		1466	/// baz(5);
		1467	/// }
		1468	/// }
		1469	///
		1470	/// void bar() { foo(true); }
		1471	/// } // namespace N
		1472	/// \endcode
		1473	BS_Mozilla,
		1474	/// Like ``Attach``, but break before function definitions, ``catch``, and
		1475	/// ``else``.
		1476	/// \code
		1477	/// namespace N {
		1478	/// enum E {
		1479	/// E1,
		1480	/// E2,
		1481	/// };
		1482	///
		1483	/// class C {
		1484	/// public:
		1485	/// C();
		1486	/// };
		1487	///
		1488	/// bool baz(int i)
		1489	/// {
		1490	/// try {
		1491	/// do {
		1492	/// switch (i) {
		1493	/// case 1: {
		1494	/// foobar();
		1495	/// break;
		1496	/// }
		1497	/// default: {
		1498	/// break;
		1499	/// }
		1500	/// }
		1501	/// } while (--i);
		1502	/// return true;
		1503	/// }
		1504	/// catch (...) {
		1505	/// handleError();
		1506	/// return false;
		1507	/// }
		1508	/// }
		1509	///
		1510	/// void foo(bool b)
		1511	/// {
		1512	/// if (b) {
		1513	/// baz(2);
		1514	/// }
		1515	/// else {
		1516	/// baz(5);
		1517	/// }
		1518	/// }
		1519	///
		1520	/// void bar() { foo(true); }
		1521	/// } // namespace N
		1522	/// \endcode
		1523	BS_Stroustrup,
		1524	/// Always break before braces.
		1525	/// \code
		1526	/// namespace N
		1527	/// {
		1528	/// enum E
		1529	/// {
		1530	/// E1,
		1531	/// E2,
		1532	/// };
		1533	///
		1534	/// class C
		1535	/// {
		1536	/// public:
		1537	/// C();
		1538	/// };
		1539	///
		1540	/// bool baz(int i)
		1541	/// {
		1542	/// try
		1543	/// {
		1544	/// do
		1545	/// {
		1546	/// switch (i)
		1547	/// {
		1548	/// case 1:
		1549	/// {
		1550	/// foobar();
		1551	/// break;
		1552	/// }
		1553	/// default:
		1554	/// {
		1555	/// break;
		1556	/// }
		1557	/// }
		1558	/// } while (--i);
		1559	/// return true;
		1560	/// }
		1561	/// catch (...)
		1562	/// {
		1563	/// handleError();
		1564	/// return false;
		1565	/// }
		1566	/// }
		1567	///
		1568	/// void foo(bool b)
		1569	/// {
		1570	/// if (b)
		1571	/// {
		1572	/// baz(2);
		1573	/// }
		1574	/// else
		1575	/// {
		1576	/// baz(5);
		1577	/// }
		1578	/// }
		1579	///
		1580	/// void bar() { foo(true); }
		1581	/// } // namespace N
		1582	/// \endcode
		1583	BS_Allman,
		1584	/// Like ``Allman`` but always indent braces and line up code with braces.
		1585	/// \code
		1586	/// namespace N
		1587	/// {
		1588	/// enum E
		1589	/// {
		1590	/// E1,
		1591	/// E2,
		1592	/// };
		1593	///
		1594	/// class C
		1595	/// {
		1596	/// public:
		1597	/// C();
		1598	/// };
		1599	///
		1600	/// bool baz(int i)
		1601	/// {
		1602	/// try
		1603	/// {
		1604	/// do
		1605	/// {
		1606	/// switch (i)
		1607	/// {
		1608	/// case 1:
		1609	/// {
		1610	/// foobar();
		1611	/// break;
		1612	/// }
		1613	/// default:
		1614	/// {
		1615	/// break;
		1616	/// }
		1617	/// }
		1618	/// } while (--i);
		1619	/// return true;
		1620	/// }
		1621	/// catch (...)
		1622	/// {
		1623	/// handleError();
		1624	/// return false;
		1625	/// }
		1626	/// }
		1627	///
		1628	/// void foo(bool b)
		1629	/// {
		1630	/// if (b)
		1631	/// {
		1632	/// baz(2);
		1633	/// }
		1634	/// else
		1635	/// {
		1636	/// baz(5);
		1637	/// }
		1638	/// }
		1639	///
		1640	/// void bar() { foo(true); }
		1641	/// } // namespace N
		1642	/// \endcode
		1643	BS_Whitesmiths,
		1644	/// Always break before braces and add an extra level of indentation to
		1645	/// braces of control statements, not to those of class, function
		1646	/// or other definitions.
		1647	/// \code
		1648	/// namespace N
		1649	/// {
		1650	/// enum E
		1651	/// {
		1652	/// E1,
		1653	/// E2,
		1654	/// };
		1655	///
		1656	/// class C
		1657	/// {
		1658	/// public:
		1659	/// C();
		1660	/// };
		1661	///
		1662	/// bool baz(int i)
		1663	/// {
		1664	/// try
		1665	/// {
		1666	/// do
		1667	/// {
		1668	/// switch (i)
		1669	/// {
		1670	/// case 1:
		1671	/// {
		1672	/// foobar();
		1673	/// break;
		1674	/// }
		1675	/// default:
		1676	/// {
		1677	/// break;
		1678	/// }
		1679	/// }
		1680	/// }
		1681	/// while (--i);
		1682	/// return true;
		1683	/// }
		1684	/// catch (...)
		1685	/// {
		1686	/// handleError();
		1687	/// return false;
		1688	/// }
		1689	/// }
		1690	///
		1691	/// void foo(bool b)
		1692	/// {
		1693	/// if (b)
		1694	/// {
		1695	/// baz(2);
		1696	/// }
		1697	/// else
		1698	/// {
		1699	/// baz(5);
		1700	/// }
		1701	/// }
		1702	///
		1703	/// void bar() { foo(true); }
		1704	/// } // namespace N
		1705	/// \endcode
		1706	BS_GNU,
		1707	/// Like ``Attach``, but break before functions.
		1708	/// \code
		1709	/// namespace N {
		1710	/// enum E {
		1711	/// E1,
		1712	/// E2,
		1713	/// };
		1714	///
		1715	/// class C {
		1716	/// public:
		1717	/// C();
		1718	/// };
		1719	///
		1720	/// bool baz(int i)
		1721	/// {
		1722	/// try {
		1723	/// do {
		1724	/// switch (i) {
		1725	/// case 1: {
		1726	/// foobar();
		1727	/// break;
		1728	/// }
		1729	/// default: {
		1730	/// break;
		1731	/// }
		1732	/// }
		1733	/// } while (--i);
		1734	/// return true;
		1735	/// } catch (...) {
		1736	/// handleError();
		1737	/// return false;
		1738	/// }
		1739	/// }
		1740	///
		1741	/// void foo(bool b)
		1742	/// {
		1743	/// if (b) {
		1744	/// baz(2);
		1745	/// } else {
		1746	/// baz(5);
		1747	/// }
		1748	/// }
		1749	///
		1750	/// void bar() { foo(true); }
		1751	/// } // namespace N
		1752	/// \endcode
		1753	BS_WebKit,
		1754	/// Configure each individual brace in `BraceWrapping`.
		1755	BS_Custom
		1756	};
		1757
		1758	/// The brace breaking style to use.
		1759	/// \version 3.7
		1760	BraceBreakingStyle BreakBeforeBraces;
		1761
		1762	/// Different ways to break before concept declarations.
		1763	enum BreakBeforeConceptDeclarationsStyle : int8_t {
		1764	/// Keep the template declaration line together with ``concept``.
		1765	/// \code
		1766	/// template <typename T> concept C = ...;
		1767	/// \endcode
		1768	BBCDS_Never,
		1769	/// Breaking between template declaration and ``concept`` is allowed. The
		1770	/// actual behavior depends on the content and line breaking rules and
		1771	/// penalities.
		1772	BBCDS_Allowed,
		1773	/// Always break before ``concept``, putting it in the line after the
		1774	/// template declaration.
		1775	/// \code
		1776	/// template <typename T>
		1777	/// concept C = ...;
		1778	/// \endcode
		1779	BBCDS_Always,
		1780	};
		1781
		1782	/// The concept declaration style to use.
		1783	/// \version 12
		1784	BreakBeforeConceptDeclarationsStyle BreakBeforeConceptDeclarations;
		1785
		1786	/// Different ways to break ASM parameters.
		1787	enum BreakBeforeInlineASMColonStyle : int8_t {
		1788	/// No break before inline ASM colon.
		1789	/// \code
		1790	/// asm volatile("string", : : val);
		1791	/// \endcode
		1792	BBIAS_Never,
		1793	/// Break before inline ASM colon if the line length is longer than column
		1794	/// limit.
		1795	/// \code
		1796	/// asm volatile("string", : : val);
		1797	/// asm("cmoveq %1, %2, %[result]"
		1798	/// : [result] "=r"(result)
		1799	/// : "r"(test), "r"(new), "[result]"(old));
		1800	/// \endcode
		1801	BBIAS_OnlyMultiline,
		1802	/// Always break before inline ASM colon.
		1803	/// \code
		1804	/// asm volatile("string",
		1805	/// :
		1806	/// : val);
		1807	/// \endcode
		1808	BBIAS_Always,
		1809	};
		1810
		1811	/// The inline ASM colon style to use.
		1812	/// \version 16
		1813	BreakBeforeInlineASMColonStyle BreakBeforeInlineASMColon;
		1814
		1815	/// If ``true``, ternary operators will be placed after line breaks.
		1816	/// \code
		1817	/// true:
		1818	/// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
		1819	/// ? firstValue
		1820	/// : SecondValueVeryVeryVeryVeryLong;
		1821	///
		1822	/// false:
		1823	/// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
		1824	/// firstValue :
		1825	/// SecondValueVeryVeryVeryVeryLong;
		1826	/// \endcode
		1827	/// \version 3.7
		1828	bool BreakBeforeTernaryOperators;
		1829
		1830	/// Different ways to break initializers.
		1831	enum BreakConstructorInitializersStyle : int8_t {
		1832	/// Break constructor initializers before the colon and after the commas.
		1833	/// \code
		1834	/// Constructor()
		1835	/// : initializer1(),
		1836	/// initializer2()
		1837	/// \endcode
		1838	BCIS_BeforeColon,
		1839	/// Break constructor initializers before the colon and commas, and align
		1840	/// the commas with the colon.
		1841	/// \code
		1842	/// Constructor()
		1843	/// : initializer1()
		1844	/// , initializer2()
		1845	/// \endcode
		1846	BCIS_BeforeComma,
		1847	/// Break constructor initializers after the colon and commas.
		1848	/// \code
		1849	/// Constructor() :
		1850	/// initializer1(),
		1851	/// initializer2()
		1852	/// \endcode
		1853	BCIS_AfterColon
		1854	};
		1855
		1856	/// The break constructor initializers style to use.
		1857	/// \version 5
		1858	BreakConstructorInitializersStyle BreakConstructorInitializers;
		1859
		1860	/// Break after each annotation on a field in Java files.
		1861	/// \code{.java}
		1862	/// true: false:
		1863	/// @Partial vs. @Partial @Mock DataLoad loader;
		1864	/// @Mock
		1865	/// DataLoad loader;
		1866	/// \endcode
		1867	/// \version 3.8
		1868	bool BreakAfterJavaFieldAnnotations;
		1869
		1870	/// Allow breaking string literals when formatting.
		1871	/// \code
		1872	/// true:
		1873	/// const char* x = "veryVeryVeryVeryVeryVe"
		1874	/// "ryVeryVeryVeryVeryVery"
		1875	/// "VeryLongString";
		1876	///
		1877	/// false:
		1878	/// const char* x =
		1879	/// "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";
		1880	/// \endcode
		1881	/// \version 3.9
		1882	bool BreakStringLiterals;
		1883
		1884	/// The column limit.
		1885	///
		1886	/// A column limit of ``0`` means that there is no column limit. In this case,
		1887	/// clang-format will respect the input's line breaking decisions within
		1888	/// statements unless they contradict other rules.
		1889	/// \version 3.7
		1890	unsigned ColumnLimit;
		1891
		1892	/// A regular expression that describes comments with special meaning,
		1893	/// which should not be split into lines or otherwise changed.
		1894	/// \code
		1895	/// // CommentPragmas: '^ FOOBAR pragma:'
		1896	/// // Will leave the following line unaffected
		1897	/// #include <vector> // FOOBAR pragma: keep
		1898	/// \endcode
		1899	/// \version 3.7
		1900	std::string CommentPragmas;
		1901
		1902	/// Different ways to break inheritance list.
		1903	enum BreakInheritanceListStyle : int8_t {
		1904	/// Break inheritance list before the colon and after the commas.
		1905	/// \code
		1906	/// class Foo
		1907	/// : Base1,
		1908	/// Base2
		1909	/// {};
		1910	/// \endcode
		1911	BILS_BeforeColon,
		1912	/// Break inheritance list before the colon and commas, and align
		1913	/// the commas with the colon.
		1914	/// \code
		1915	/// class Foo
		1916	/// : Base1
		1917	/// , Base2
		1918	/// {};
		1919	/// \endcode
		1920	BILS_BeforeComma,
		1921	/// Break inheritance list after the colon and commas.
		1922	/// \code
		1923	/// class Foo :
		1924	/// Base1,
		1925	/// Base2
		1926	/// {};
		1927	/// \endcode
		1928	BILS_AfterColon,
		1929	/// Break inheritance list only after the commas.
		1930	/// \code
		1931	/// class Foo : Base1,
		1932	/// Base2
		1933	/// {};
		1934	/// \endcode
		1935	BILS_AfterComma,
		1936	};
		1937
		1938	/// The inheritance list style to use.
		1939	/// \version 7
		1940	BreakInheritanceListStyle BreakInheritanceList;
		1941
		1942	/// If ``true``, consecutive namespace declarations will be on the same
		1943	/// line. If ``false``, each namespace is declared on a new line.
		1944	/// \code
		1945	/// true:
		1946	/// namespace Foo { namespace Bar {
		1947	/// }}
		1948	///
		1949	/// false:
		1950	/// namespace Foo {
		1951	/// namespace Bar {
		1952	/// }
		1953	/// }
		1954	/// \endcode
		1955	///
		1956	/// If it does not fit on a single line, the overflowing namespaces get
		1957	/// wrapped:
		1958	/// \code
		1959	/// namespace Foo { namespace Bar {
		1960	/// namespace Extra {
		1961	/// }}}
		1962	/// \endcode
		1963	/// \version 5
		1964	bool CompactNamespaces;
		1965
		1966	/// This option is deprecated. See ``CurrentLine`` of
		1967	/// ``PackConstructorInitializers``.
		1968	/// \version 3.7
		1969	// bool ConstructorInitializerAllOnOneLineOrOnePerLine;
		1970
		1971	/// The number of characters to use for indentation of constructor
		1972	/// initializer lists as well as inheritance lists.
		1973	/// \version 3.7
		1974	unsigned ConstructorInitializerIndentWidth;
		1975
		1976	/// Indent width for line continuations.
		1977	/// \code
		1978	/// ContinuationIndentWidth: 2
		1979	///
		1980	/// int i = // VeryVeryVeryVeryVeryLongComment
		1981	/// longFunction( // Again a long comment
		1982	/// arg);
		1983	/// \endcode
		1984	/// \version 3.7
		1985	unsigned ContinuationIndentWidth;
		1986
		1987	/// If ``true``, format braced lists as best suited for C++11 braced
		1988	/// lists.
		1989	///
		1990	/// Important differences:
		1991	/// - No spaces inside the braced list.
		1992	/// - No line break before the closing brace.
		1993	/// - Indentation with the continuation indent, not with the block indent.
		1994	///
		1995	/// Fundamentally, C++11 braced lists are formatted exactly like function
		1996	/// calls would be formatted in their place. If the braced list follows a name
		1997	/// (e.g. a type or variable name), clang-format formats as if the ``{}`` were
		1998	/// the parentheses of a function call with that name. If there is no name,
		1999	/// a zero-length name is assumed.
		2000	/// \code
		2001	/// true: false:
		2002	/// vector<int> x{1, 2, 3, 4}; vs. vector<int> x{ 1, 2, 3, 4 };
		2003	/// vector<T> x{{}, {}, {}, {}}; vector<T> x{ {}, {}, {}, {} };
		2004	/// f(MyMap[{composite, key}]); f(MyMap[{ composite, key }]);
		2005	/// new int[3]{1, 2, 3}; new int[3]{ 1, 2, 3 };
		2006	/// \endcode
		2007	/// \version 3.4
		2008	bool Cpp11BracedListStyle;
		2009
		2010	/// This option is deprecated. See ``DeriveLF`` and ``DeriveCRLF`` of
		2011	/// ``LineEnding``.
		2012	/// \version 10
		2013	// bool DeriveLineEnding;
		2014
		2015	/// If ``true``, analyze the formatted file for the most common
		2016	/// alignment of ``&`` and ``*``.
		2017	/// Pointer and reference alignment styles are going to be updated according
		2018	/// to the preferences found in the file.
		2019	/// ``PointerAlignment`` is then used only as fallback.
		2020	/// \version 3.7
		2021	bool DerivePointerAlignment;
		2022
		2023	/// Disables formatting completely.
		2024	/// \version 3.7
		2025	bool DisableFormat;
		2026
		2027	/// Different styles for empty line after access modifiers.
		2028	/// ``EmptyLineBeforeAccessModifier`` configuration handles the number of
		2029	/// empty lines between two access modifiers.
		2030	enum EmptyLineAfterAccessModifierStyle : int8_t {
		2031	/// Remove all empty lines after access modifiers.
		2032	/// \code
		2033	/// struct foo {
		2034	/// private:
		2035	/// int i;
		2036	/// protected:
		2037	/// int j;
		2038	/// /* comment */
		2039	/// public:
		2040	/// foo() {}
		2041	/// private:
		2042	/// protected:
		2043	/// };
		2044	/// \endcode
		2045	ELAAMS_Never,
		2046	/// Keep existing empty lines after access modifiers.
		2047	/// MaxEmptyLinesToKeep is applied instead.
		2048	ELAAMS_Leave,
		2049	/// Always add empty line after access modifiers if there are none.
		2050	/// MaxEmptyLinesToKeep is applied also.
		2051	/// \code
		2052	/// struct foo {
		2053	/// private:
		2054	///
		2055	/// int i;
		2056	/// protected:
		2057	///
		2058	/// int j;
		2059	/// /* comment */
		2060	/// public:
		2061	///
		2062	/// foo() {}
		2063	/// private:
		2064	///
		2065	/// protected:
		2066	///
		2067	/// };
		2068	/// \endcode
		2069	ELAAMS_Always,
		2070	};
		2071
		2072	/// Defines when to put an empty line after access modifiers.
		2073	/// ``EmptyLineBeforeAccessModifier`` configuration handles the number of
		2074	/// empty lines between two access modifiers.
		2075	/// \version 13
		2076	EmptyLineAfterAccessModifierStyle EmptyLineAfterAccessModifier;
		2077
		2078	/// Different styles for empty line before access modifiers.
		2079	enum EmptyLineBeforeAccessModifierStyle : int8_t {
		2080	/// Remove all empty lines before access modifiers.
		2081	/// \code
		2082	/// struct foo {
		2083	/// private:
		2084	/// int i;
		2085	/// protected:
		2086	/// int j;
		2087	/// /* comment */
		2088	/// public:
		2089	/// foo() {}
		2090	/// private:
		2091	/// protected:
		2092	/// };
		2093	/// \endcode
		2094	ELBAMS_Never,
		2095	/// Keep existing empty lines before access modifiers.
		2096	ELBAMS_Leave,
		2097	/// Add empty line only when access modifier starts a new logical block.
		2098	/// Logical block is a group of one or more member fields or functions.
		2099	/// \code
		2100	/// struct foo {
		2101	/// private:
		2102	/// int i;
		2103	///
		2104	/// protected:
		2105	/// int j;
		2106	/// /* comment */
		2107	/// public:
		2108	/// foo() {}
		2109	///
		2110	/// private:
		2111	/// protected:
		2112	/// };
		2113	/// \endcode
		2114	ELBAMS_LogicalBlock,
		2115	/// Always add empty line before access modifiers unless access modifier
		2116	/// is at the start of struct or class definition.
		2117	/// \code
		2118	/// struct foo {
		2119	/// private:
		2120	/// int i;
		2121	///
		2122	/// protected:
		2123	/// int j;
		2124	/// /* comment */
		2125	///
		2126	/// public:
		2127	/// foo() {}
		2128	///
		2129	/// private:
		2130	///
		2131	/// protected:
		2132	/// };
		2133	/// \endcode
		2134	ELBAMS_Always,
		2135	};
		2136
		2137	/// Defines in which cases to put empty line before access modifiers.
		2138	/// \version 12
		2139	EmptyLineBeforeAccessModifierStyle EmptyLineBeforeAccessModifier;
		2140
		2141	/// If ``true``, clang-format detects whether function calls and
		2142	/// definitions are formatted with one parameter per line.
		2143	///
		2144	/// Each call can be bin-packed, one-per-line or inconclusive. If it is
		2145	/// inconclusive, e.g. completely on one line, but a decision needs to be
		2146	/// made, clang-format analyzes whether there are other bin-packed cases in
		2147	/// the input file and act accordingly.
		2148	///
		2149	/// NOTE: This is an experimental flag, that might go away or be renamed. Do
		2150	/// not use this in config files, etc. Use at your own risk.
		2151	/// \version 3.7
		2152	bool ExperimentalAutoDetectBinPacking;
		2153
		2154	/// If ``true``, clang-format adds missing namespace end comments for
		2155	/// namespaces and fixes invalid existing ones. This doesn't affect short
		2156	/// namespaces, which are controlled by ``ShortNamespaceLines``.
		2157	/// \code
		2158	/// true: false:
		2159	/// namespace longNamespace { vs. namespace longNamespace {
		2160	/// void foo(); void foo();
		2161	/// void bar(); void bar();
		2162	/// } // namespace a }
		2163	/// namespace shortNamespace { namespace shortNamespace {
		2164	/// void baz(); void baz();
		2165	/// } }
		2166	/// \endcode
		2167	/// \version 5
		2168	bool FixNamespaceComments;
		2169
		2170	/// A vector of macros that should be interpreted as foreach loops
		2171	/// instead of as function calls.
		2172	///
		2173	/// These are expected to be macros of the form:
		2174	/// \code
		2175	/// FOREACH(<variable-declaration>, ...)
		2176	/// <loop-body>
		2177	/// \endcode
		2178	///
		2179	/// In the .clang-format configuration file, this can be configured like:
		2180	/// \code{.yaml}
		2181	/// ForEachMacros: ['RANGES_FOR', 'FOREACH']
		2182	/// \endcode
		2183	///
		2184	/// For example: BOOST_FOREACH.
		2185	/// \version 3.7
		2186	std::vector<std::string> ForEachMacros;
		2187
		2188	tooling::IncludeStyle IncludeStyle;
		2189
		2190	/// A vector of macros that should be interpreted as conditionals
		2191	/// instead of as function calls.
		2192	///
		2193	/// These are expected to be macros of the form:
		2194	/// \code
		2195	/// IF(...)
		2196	/// <conditional-body>
		2197	/// else IF(...)
		2198	/// <conditional-body>
		2199	/// \endcode
		2200	///
		2201	/// In the .clang-format configuration file, this can be configured like:
		2202	/// \code{.yaml}
		2203	/// IfMacros: ['IF']
		2204	/// \endcode
		2205	///
		2206	/// For example: `KJ_IF_MAYBE
		2207	/// <https://github.com/capnproto/capnproto/blob/master/kjdoc/tour.md#maybes>`_
		2208	/// \version 13
		2209	std::vector<std::string> IfMacros;
		2210
		2211	/// Specify whether access modifiers should have their own indentation level.
		2212	///
		2213	/// When ``false``, access modifiers are indented (or outdented) relative to
		2214	/// the record members, respecting the ``AccessModifierOffset``. Record
		2215	/// members are indented one level below the record.
		2216	/// When ``true``, access modifiers get their own indentation level. As a
		2217	/// consequence, record members are always indented 2 levels below the record,
		2218	/// regardless of the access modifier presence. Value of the
		2219	/// ``AccessModifierOffset`` is ignored.
		2220	/// \code
		2221	/// false: true:
		2222	/// class C { vs. class C {
		2223	/// class D { class D {
		2224	/// void bar(); void bar();
		2225	/// protected: protected:
		2226	/// D(); D();
		2227	/// }; };
		2228	/// public: public:
		2229	/// C(); C();
		2230	/// }; };
		2231	/// void foo() { void foo() {
		2232	/// return 1; return 1;
		2233	/// } }
		2234	/// \endcode
		2235	/// \version 13
		2236	bool IndentAccessModifiers;
		2237
		2238	/// Indent case label blocks one level from the case label.
		2239	///
		2240	/// When ``false``, the block following the case label uses the same
		2241	/// indentation level as for the case label, treating the case label the same
		2242	/// as an if-statement.
		2243	/// When ``true``, the block gets indented as a scope block.
		2244	/// \code
		2245	/// false: true:
		2246	/// switch (fool) { vs. switch (fool) {
		2247	/// case 1: { case 1:
		2248	/// bar(); {
		2249	/// } break; bar();
		2250	/// default: { }
		2251	/// plop(); break;
		2252	/// } default:
		2253	/// } {
		2254	/// plop();
		2255	/// }
		2256	/// }
		2257	/// \endcode
		2258	/// \version 11
		2259	bool IndentCaseBlocks;
		2260
		2261	/// Indent case labels one level from the switch statement.
		2262	///
		2263	/// When ``false``, use the same indentation level as for the switch
		2264	/// statement. Switch statement body is always indented one level more than
		2265	/// case labels (except the first block following the case label, which
		2266	/// itself indents the code - unless IndentCaseBlocks is enabled).
		2267	/// \code
		2268	/// false: true:
		2269	/// switch (fool) { vs. switch (fool) {
		2270	/// case 1: case 1:
		2271	/// bar(); bar();
		2272	/// break; break;
		2273	/// default: default:
		2274	/// plop(); plop();
		2275	/// } }
		2276	/// \endcode
		2277	/// \version 3.3
		2278	bool IndentCaseLabels;
		2279
		2280	/// Indent goto labels.
		2281	///
		2282	/// When ``false``, goto labels are flushed left.
		2283	/// \code
		2284	/// true: false:
		2285	/// int f() { vs. int f() {
		2286	/// if (foo()) { if (foo()) {
		2287	/// label1: label1:
		2288	/// bar(); bar();
		2289	/// } }
		2290	/// label2: label2:
		2291	/// return 1; return 1;
		2292	/// } }
		2293	/// \endcode
		2294	/// \version 10
		2295	bool IndentGotoLabels;
		2296
		2297	/// Indents extern blocks
		2298	enum IndentExternBlockStyle : int8_t {
		2299	/// Backwards compatible with AfterExternBlock's indenting.
		2300	/// \code
		2301	/// IndentExternBlock: AfterExternBlock
		2302	/// BraceWrapping.AfterExternBlock: true
		2303	/// extern "C"
		2304	/// {
		2305	/// void foo();
		2306	/// }
		2307	/// \endcode
		2308	///
		2309	/// \code
		2310	/// IndentExternBlock: AfterExternBlock
		2311	/// BraceWrapping.AfterExternBlock: false
		2312	/// extern "C" {
		2313	/// void foo();
		2314	/// }
		2315	/// \endcode
		2316	IEBS_AfterExternBlock,
		2317	/// Does not indent extern blocks.
		2318	/// \code
		2319	/// extern "C" {
		2320	/// void foo();
		2321	/// }
		2322	/// \endcode
		2323	IEBS_NoIndent,
		2324	/// Indents extern blocks.
		2325	/// \code
		2326	/// extern "C" {
		2327	/// void foo();
		2328	/// }
		2329	/// \endcode
		2330	IEBS_Indent,
		2331	};
		2332
		2333	/// IndentExternBlockStyle is the type of indenting of extern blocks.
		2334	/// \version 11
		2335	IndentExternBlockStyle IndentExternBlock;
		2336
		2337	/// Options for indenting preprocessor directives.
		2338	enum PPDirectiveIndentStyle : int8_t {
		2339	/// Does not indent any directives.
		2340	/// \code
		2341	/// #if FOO
		2342	/// #if BAR
		2343	/// #include <foo>
		2344	/// #endif
		2345	/// #endif
		2346	/// \endcode
		2347	PPDIS_None,
		2348	/// Indents directives after the hash.
		2349	/// \code
		2350	/// #if FOO
		2351	/// # if BAR
		2352	/// # include <foo>
		2353	/// # endif
		2354	/// #endif
		2355	/// \endcode
		2356	PPDIS_AfterHash,
		2357	/// Indents directives before the hash.
		2358	/// \code
		2359	/// #if FOO
		2360	/// #if BAR
		2361	/// #include <foo>
		2362	/// #endif
		2363	/// #endif
		2364	/// \endcode
		2365	PPDIS_BeforeHash
		2366	};
		2367
		2368	/// The preprocessor directive indenting style to use.
		2369	/// \version 6
		2370	PPDirectiveIndentStyle IndentPPDirectives;
		2371
		2372	/// Indent the requires clause in a template. This only applies when
		2373	/// ``RequiresClausePosition`` is ``OwnLine``, or ``WithFollowing``.
		2374	///
		2375	/// In clang-format 12, 13 and 14 it was named ``IndentRequires``.
		2376	/// \code
		2377	/// true:
		2378	/// template <typename It>
		2379	/// requires Iterator<It>
		2380	/// void sort(It begin, It end) {
		2381	/// //....
		2382	/// }
		2383	///
		2384	/// false:
		2385	/// template <typename It>
		2386	/// requires Iterator<It>
		2387	/// void sort(It begin, It end) {
		2388	/// //....
		2389	/// }
		2390	/// \endcode
		2391	/// \version 15
		2392	bool IndentRequiresClause;
		2393
		2394	/// The number of columns to use for indentation.
		2395	/// \code
		2396	/// IndentWidth: 3
		2397	///
		2398	/// void f() {
		2399	/// someFunction();
		2400	/// if (true, false) {
		2401	/// f();
		2402	/// }
		2403	/// }
		2404	/// \endcode
		2405	/// \version 3.7
		2406	unsigned IndentWidth;
		2407
		2408	/// Indent if a function definition or declaration is wrapped after the
		2409	/// type.
		2410	/// \code
		2411	/// true:
		2412	/// LoooooooooooooooooooooooooooooooooooooooongReturnType
		2413	/// LoooooooooooooooooooooooooooooooongFunctionDeclaration();
		2414	///
		2415	/// false:
		2416	/// LoooooooooooooooooooooooooooooooooooooooongReturnType
		2417	/// LoooooooooooooooooooooooooooooooongFunctionDeclaration();
		2418	/// \endcode
		2419	/// \version 3.7
		2420	bool IndentWrappedFunctionNames;
		2421
		2422	/// Insert braces after control statements (``if``, ``else``, ``for``, ``do``,
		2423	/// and ``while``) in C++ unless the control statements are inside macro
		2424	/// definitions or the braces would enclose preprocessor directives.
		2425	/// \warning
		2426	/// Setting this option to `true` could lead to incorrect code formatting due
		2427	/// to clang-format's lack of complete semantic information. As such, extra
		2428	/// care should be taken to review code changes made by this option.
		2429	/// \endwarning
		2430	/// \code
		2431	/// false: true:
		2432	///
		2433	/// if (isa<FunctionDecl>(D)) vs. if (isa<FunctionDecl>(D)) {
		2434	/// handleFunctionDecl(D); handleFunctionDecl(D);
		2435	/// else if (isa<VarDecl>(D)) } else if (isa<VarDecl>(D)) {
		2436	/// handleVarDecl(D); handleVarDecl(D);
		2437	/// else } else {
		2438	/// return; return;
		2439	/// }
		2440	///
		2441	/// while (i--) vs. while (i--) {
		2442	/// for (auto A : D.attrs()) for (auto A : D.attrs()) {
		2443	/// handleAttr(A); handleAttr(A);
		2444	/// }
		2445	/// }
		2446	///
		2447	/// do vs. do {
		2448	/// --i; --i;
		2449	/// while (i); } while (i);
		2450	/// \endcode
		2451	/// \version 15
		2452	bool InsertBraces;
		2453
		2454	/// Insert a newline at end of file if missing.
		2455	/// \version 16
		2456	bool InsertNewlineAtEOF;
		2457
		2458	/// The style of inserting trailing commas into container literals.
		2459	enum TrailingCommaStyle : int8_t {
		2460	/// Do not insert trailing commas.
		2461	TCS_None,
		2462	/// Insert trailing commas in container literals that were wrapped over
		2463	/// multiple lines. Note that this is conceptually incompatible with
		2464	/// bin-packing, because the trailing comma is used as an indicator
		2465	/// that a container should be formatted one-per-line (i.e. not bin-packed).
		2466	/// So inserting a trailing comma counteracts bin-packing.
		2467	TCS_Wrapped,
		2468	};
		2469
		2470	/// If set to ``TCS_Wrapped`` will insert trailing commas in container
		2471	/// literals (arrays and objects) that wrap across multiple lines.
		2472	/// It is currently only available for JavaScript
		2473	/// and disabled by default ``TCS_None``.
		2474	/// ``InsertTrailingCommas`` cannot be used together with ``BinPackArguments``
		2475	/// as inserting the comma disables bin-packing.
		2476	/// \code
		2477	/// TSC_Wrapped:
		2478	/// const someArray = [
		2479	/// aaaaaaaaaaaaaaaaaaaaaaaaaa,
		2480	/// aaaaaaaaaaaaaaaaaaaaaaaaaa,
		2481	/// aaaaaaaaaaaaaaaaaaaaaaaaaa,
		2482	/// // ^ inserted
		2483	/// ]
		2484	/// \endcode
		2485	/// \version 11
		2486	TrailingCommaStyle InsertTrailingCommas;
		2487
		2488	/// Separator format of integer literals of different bases.
		2489	///
		2490	/// If negative, remove separators. If ``0``, leave the literal as is. If
		2491	/// positive, insert separators between digits starting from the rightmost
		2492	/// digit.
		2493	///
		2494	/// For example, the config below will leave separators in binary literals
		2495	/// alone, insert separators in decimal literals to separate the digits into
		2496	/// groups of 3, and remove separators in hexadecimal literals.
		2497	/// \code
		2498	/// IntegerLiteralSeparator:
		2499	/// Binary: 0
		2500	/// Decimal: 3
		2501	/// Hex: -1
		2502	/// \endcode
		2503	///
		2504	/// You can also specify a minimum number of digits (``BinaryMinDigits``,
		2505	/// ``DecimalMinDigits``, and ``HexMinDigits``) the integer literal must
		2506	/// have in order for the separators to be inserted.
		2507	struct IntegerLiteralSeparatorStyle {
		2508	/// Format separators in binary literals.
		2509	/// \code{.text}
		2510	/// /* -1: */ b = 0b100111101101;
		2511	/// /* 0: */ b = 0b10011'11'0110'1;
		2512	/// /* 3: */ b = 0b100'111'101'101;
		2513	/// /* 4: */ b = 0b1001'1110'1101;
		2514	/// \endcode
		2515	int8_t Binary;
		2516	/// Format separators in binary literals with a minimum number of digits.
		2517	/// \code{.text}
		2518	/// // Binary: 3
		2519	/// // BinaryMinDigits: 7
		2520	/// b1 = 0b101101;
		2521	/// b2 = 0b1'101'101;
		2522	/// \endcode
		2523	int8_t BinaryMinDigits;
		2524	/// Format separators in decimal literals.
		2525	/// \code{.text}
		2526	/// /* -1: */ d = 18446744073709550592ull;
		2527	/// /* 0: */ d = 184467'440737'0'95505'92ull;
		2528	/// /* 3: */ d = 18'446'744'073'709'550'592ull;
		2529	/// \endcode
		2530	int8_t Decimal;
		2531	/// Format separators in decimal literals with a minimum number of digits.
		2532	/// \code{.text}
		2533	/// // Decimal: 3
		2534	/// // DecimalMinDigits: 5
		2535	/// d1 = 2023;
		2536	/// d2 = 10'000;
		2537	/// \endcode
		2538	int8_t DecimalMinDigits;
		2539	/// Format separators in hexadecimal literals.
		2540	/// \code{.text}
		2541	/// /* -1: */ h = 0xDEADBEEFDEADBEEFuz;
		2542	/// /* 0: */ h = 0xDEAD'BEEF'DE'AD'BEE'Fuz;
		2543	/// /* 2: */ h = 0xDE'AD'BE'EF'DE'AD'BE'EFuz;
		2544	/// \endcode
		2545	int8_t Hex;
		2546	/// Format separators in hexadecimal literals with a minimum number of
		2547	/// digits.
		2548	/// \code{.text}
		2549	/// // Hex: 2
		2550	/// // HexMinDigits: 6
		2551	/// h1 = 0xABCDE;
		2552	/// h2 = 0xAB'CD'EF;
		2553	/// \endcode
		2554	int8_t HexMinDigits;
		2555	bool operator==(const IntegerLiteralSeparatorStyle &R) const {
		2556	return Binary == R.Binary && BinaryMinDigits == R.BinaryMinDigits &&
		2557	Decimal == R.Decimal && DecimalMinDigits == R.DecimalMinDigits &&
		2558	Hex == R.Hex && HexMinDigits == R.HexMinDigits;
		2559	}
		2560	};
		2561
		2562	/// Format integer literal separators (``'`` for C++ and ``_`` for C#, Java,
		2563	/// and JavaScript).
		2564	/// \version 16
		2565	IntegerLiteralSeparatorStyle IntegerLiteralSeparator;
		2566
		2567	/// A vector of prefixes ordered by the desired groups for Java imports.
		2568	///
		2569	/// One group's prefix can be a subset of another - the longest prefix is
		2570	/// always matched. Within a group, the imports are ordered lexicographically.
		2571	/// Static imports are grouped separately and follow the same group rules.
		2572	/// By default, static imports are placed before non-static imports,
		2573	/// but this behavior is changed by another option,
		2574	/// ``SortJavaStaticImport``.
		2575	///
		2576	/// In the .clang-format configuration file, this can be configured like
		2577	/// in the following yaml example. This will result in imports being
		2578	/// formatted as in the Java example below.
		2579	/// \code{.yaml}
		2580	/// JavaImportGroups: ['com.example', 'com', 'org']
		2581	/// \endcode
		2582	///
		2583	/// \code{.java}
		2584	/// import static com.example.function1;
		2585	///
		2586	/// import static com.test.function2;
		2587	///
		2588	/// import static org.example.function3;
		2589	///
		2590	/// import com.example.ClassA;
		2591	/// import com.example.Test;
		2592	/// import com.example.a.ClassB;
		2593	///
		2594	/// import com.test.ClassC;
		2595	///
		2596	/// import org.example.ClassD;
		2597	/// \endcode
		2598	/// \version 8
		2599	std::vector<std::string> JavaImportGroups;
		2600
		2601	/// Quotation styles for JavaScript strings. Does not affect template
		2602	/// strings.
		2603	enum JavaScriptQuoteStyle : int8_t {
		2604	/// Leave string quotes as they are.
		2605	/// \code{.js}
		2606	/// string1 = "foo";
		2607	/// string2 = 'bar';
		2608	/// \endcode
		2609	JSQS_Leave,
		2610	/// Always use single quotes.
		2611	/// \code{.js}
		2612	/// string1 = 'foo';
		2613	/// string2 = 'bar';
		2614	/// \endcode
		2615	JSQS_Single,
		2616	/// Always use double quotes.
		2617	/// \code{.js}
		2618	/// string1 = "foo";
		2619	/// string2 = "bar";
		2620	/// \endcode
		2621	JSQS_Double
		2622	};
		2623
		2624	/// The JavaScriptQuoteStyle to use for JavaScript strings.
		2625	/// \version 3.9
		2626	JavaScriptQuoteStyle JavaScriptQuotes;
		2627
		2628	// clang-format off
		2629	/// Whether to wrap JavaScript import/export statements.
		2630	/// \code{.js}
		2631	/// true:
		2632	/// import {
		2633	/// VeryLongImportsAreAnnoying,
		2634	/// VeryLongImportsAreAnnoying,
		2635	/// VeryLongImportsAreAnnoying,
		2636	/// } from 'some/module.js'
		2637	///
		2638	/// false:
		2639	/// import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js"
		2640	/// \endcode
		2641	/// \version 3.9
		2642	bool JavaScriptWrapImports;
		2643	// clang-format on
		2644
		2645	/// If true, the empty line at the start of blocks is kept.
		2646	/// \code
		2647	/// true: false:
		2648	/// if (foo) { vs. if (foo) {
		2649	/// bar();
		2650	/// bar(); }
		2651	/// }
		2652	/// \endcode
		2653	/// \version 3.7
		2654	bool KeepEmptyLinesAtTheStartOfBlocks;
		2655
		2656	/// Indentation logic for lambda bodies.
		2657	enum LambdaBodyIndentationKind : int8_t {
		2658	/// Align lambda body relative to the lambda signature. This is the default.
		2659	/// \code
		2660	/// someMethod(
		2661	/// [](SomeReallyLongLambdaSignatureArgument foo) {
		2662	/// return;
		2663	/// });
		2664	/// \endcode
		2665	LBI_Signature,
		2666	/// Align lambda body relative to the indentation level of the outer scope
		2667	/// the lambda signature resides in.
		2668	/// \code
		2669	/// someMethod(
		2670	/// [](SomeReallyLongLambdaSignatureArgument foo) {
		2671	/// return;
		2672	/// });
		2673	/// \endcode
		2674	LBI_OuterScope,
		2675	};
		2676
		2677	/// The indentation style of lambda bodies. ``Signature`` (the default)
		2678	/// causes the lambda body to be indented one additional level relative to
		2679	/// the indentation level of the signature. ``OuterScope`` forces the lambda
		2680	/// body to be indented one additional level relative to the parent scope
		2681	/// containing the lambda signature. For callback-heavy code, it may improve
		2682	/// readability to have the signature indented two levels and to use
		2683	/// ``OuterScope``. The KJ style guide requires ``OuterScope``.
		2684	/// `KJ style guide
		2685	/// <https://github.com/capnproto/capnproto/blob/master/style-guide.md>`_
		2686	/// \version 13
		2687	LambdaBodyIndentationKind LambdaBodyIndentation;
		2688
		2689	/// Supported languages.
		2690	///
		2691	/// When stored in a configuration file, specifies the language, that the
		2692	/// configuration targets. When passed to the ``reformat()`` function, enables
		2693	/// syntax features specific to the language.
		2694	enum LanguageKind : int8_t {
		2695	/// Do not use.
		2696	LK_None,
		2697	/// Should be used for C, C++.
		2698	LK_Cpp,
		2699	/// Should be used for C#.
		2700	LK_CSharp,
		2701	/// Should be used for Java.
		2702	LK_Java,
		2703	/// Should be used for JavaScript.
		2704	LK_JavaScript,
		2705	/// Should be used for JSON.
		2706	LK_Json,
		2707	/// Should be used for Objective-C, Objective-C++.
		2708	LK_ObjC,
		2709	/// Should be used for Protocol Buffers
		2710	/// (https://developers.google.com/protocol-buffers/).
		2711	LK_Proto,
		2712	/// Should be used for TableGen code.
		2713	LK_TableGen,
		2714	/// Should be used for Protocol Buffer messages in text format
		2715	/// (https://developers.google.com/protocol-buffers/).
		2716	LK_TextProto,
		2717	/// Should be used for Verilog and SystemVerilog.
		2718	/// https://standards.ieee.org/ieee/1800/6700/
		2719	/// https://sci-hub.st/10.1109/IEEESTD.2018.8299595
		2720	LK_Verilog
		2721	};
		2722	bool isCpp() const { return Language == LK_Cpp \|\| Language == LK_ObjC; }
		2723	bool isCSharp() const { return Language == LK_CSharp; }
		2724	bool isJson() const { return Language == LK_Json; }
		2725	bool isJavaScript() const { return Language == LK_JavaScript; }
		2726	bool isVerilog() const { return Language == LK_Verilog; }
		2727	bool isProto() const { return Language == LK_Proto; }
		2728
		2729	/// Language, this format style is targeted at.
		2730	/// \version 3.5
		2731	LanguageKind Language;
		2732
		2733	/// Line ending style.
		2734	enum LineEndingStyle : int8_t {
		2735	/// Use ``\n``.
		2736	LE_LF,
		2737	/// Use ``\r\n``.
		2738	LE_CRLF,
		2739	/// Use ``\n`` unless the input has more lines ending in ``\r\n``.
		2740	LE_DeriveLF,
		2741	/// Use ``\r\n`` unless the input has more lines ending in ``\n``.
		2742	LE_DeriveCRLF,
		2743	};
		2744
		2745	/// Line ending style (``\n`` or ``\r\n``) to use.
		2746	/// \version 16
		2747	LineEndingStyle LineEnding;
		2748
		2749	/// A regular expression matching macros that start a block.
		2750	/// \code
		2751	/// # With:
		2752	/// MacroBlockBegin: "^NS_MAP_BEGIN\|\
		2753	/// NS_TABLE_HEAD$"
		2754	/// MacroBlockEnd: "^\
		2755	/// NS_MAP_END\|\
		2756	/// NS_TABLE_.*_END$"
		2757	///
		2758	/// NS_MAP_BEGIN
		2759	/// foo();
		2760	/// NS_MAP_END
		2761	///
		2762	/// NS_TABLE_HEAD
		2763	/// bar();
		2764	/// NS_TABLE_FOO_END
		2765	///
		2766	/// # Without:
		2767	/// NS_MAP_BEGIN
		2768	/// foo();
		2769	/// NS_MAP_END
		2770	///
		2771	/// NS_TABLE_HEAD
		2772	/// bar();
		2773	/// NS_TABLE_FOO_END
		2774	/// \endcode
		2775	/// \version 3.7
		2776	std::string MacroBlockBegin;
		2777
		2778	/// A regular expression matching macros that end a block.
		2779	/// \version 3.7
		2780	std::string MacroBlockEnd;
		2781
		2782	/// The maximum number of consecutive empty lines to keep.
		2783	/// \code
		2784	/// MaxEmptyLinesToKeep: 1 vs. MaxEmptyLinesToKeep: 0
		2785	/// int f() { int f() {
		2786	/// int = 1; int i = 1;
		2787	/// i = foo();
		2788	/// i = foo(); return i;
		2789	/// }
		2790	/// return i;
		2791	/// }
		2792	/// \endcode
		2793	/// \version 3.7
		2794	unsigned MaxEmptyLinesToKeep;
		2795
		2796	/// Different ways to indent namespace contents.
		2797	enum NamespaceIndentationKind : int8_t {
		2798	/// Don't indent in namespaces.
		2799	/// \code
		2800	/// namespace out {
		2801	/// int i;
		2802	/// namespace in {
		2803	/// int i;
		2804	/// }
		2805	/// }
		2806	/// \endcode
		2807	NI_None,
		2808	/// Indent only in inner namespaces (nested in other namespaces).
		2809	/// \code
		2810	/// namespace out {
		2811	/// int i;
		2812	/// namespace in {
		2813	/// int i;
		2814	/// }
		2815	/// }
		2816	/// \endcode
		2817	NI_Inner,
		2818	/// Indent in all namespaces.
		2819	/// \code
		2820	/// namespace out {
		2821	/// int i;
		2822	/// namespace in {
		2823	/// int i;
		2824	/// }
		2825	/// }
		2826	/// \endcode
		2827	NI_All
		2828	};
		2829
		2830	/// The indentation used for namespaces.
		2831	/// \version 3.7
		2832	NamespaceIndentationKind NamespaceIndentation;
		2833
		2834	/// A vector of macros which are used to open namespace blocks.
		2835	///
		2836	/// These are expected to be macros of the form:
		2837	/// \code
		2838	/// NAMESPACE(<namespace-name>, ...) {
		2839	/// <namespace-content>
		2840	/// }
		2841	/// \endcode
		2842	///
		2843	/// For example: TESTSUITE
		2844	/// \version 9
		2845	std::vector<std::string> NamespaceMacros;
		2846
		2847	/// Controls bin-packing Objective-C protocol conformance list
		2848	/// items into as few lines as possible when they go over ``ColumnLimit``.
		2849	///
		2850	/// If ``Auto`` (the default), delegates to the value in
		2851	/// ``BinPackParameters``. If that is ``true``, bin-packs Objective-C
		2852	/// protocol conformance list items into as few lines as possible
		2853	/// whenever they go over ``ColumnLimit``.
		2854	///
		2855	/// If ``Always``, always bin-packs Objective-C protocol conformance
		2856	/// list items into as few lines as possible whenever they go over
		2857	/// ``ColumnLimit``.
		2858	///
		2859	/// If ``Never``, lays out Objective-C protocol conformance list items
		2860	/// onto individual lines whenever they go over ``ColumnLimit``.
		2861	///
		2862	/// \code{.objc}
		2863	/// Always (or Auto, if BinPackParameters=true):
		2864	/// @interface ccccccccccccc () <
		2865	/// ccccccccccccc, ccccccccccccc,
		2866	/// ccccccccccccc, ccccccccccccc> {
		2867	/// }
		2868	///
		2869	/// Never (or Auto, if BinPackParameters=false):
		2870	/// @interface ddddddddddddd () <
		2871	/// ddddddddddddd,
		2872	/// ddddddddddddd,
		2873	/// ddddddddddddd,
		2874	/// ddddddddddddd> {
		2875	/// }
		2876	/// \endcode
		2877	/// \version 7
		2878	BinPackStyle ObjCBinPackProtocolList;
		2879
		2880	/// The number of characters to use for indentation of ObjC blocks.
		2881	/// \code{.objc}
		2882	/// ObjCBlockIndentWidth: 4
		2883	///
		2884	/// [operation setCompletionBlock:^{
		2885	/// [self onOperationDone];
		2886	/// }];
		2887	/// \endcode
		2888	/// \version 3.7
		2889	unsigned ObjCBlockIndentWidth;
		2890
		2891	/// Break parameters list into lines when there is nested block
		2892	/// parameters in a function call.
		2893	/// \code
		2894	/// false:
		2895	/// - (void)_aMethod
		2896	/// {
		2897	/// [self.test1 t:self w:self callback:^(typeof(self) self, NSNumber
		2898	/// u, NSNumber v) {
		2899	/// u = c;
		2900	/// }]
		2901	/// }
		2902	/// true:
		2903	/// - (void)_aMethod
		2904	/// {
		2905	/// [self.test1 t:self
		2906	/// w:self
		2907	/// callback:^(typeof(self) self, NSNumber u, NSNumber v) {
		2908	/// u = c;
		2909	/// }]
		2910	/// }
		2911	/// \endcode
		2912	/// \version 11
		2913	bool ObjCBreakBeforeNestedBlockParam;
		2914
		2915	/// Add a space after ``@property`` in Objective-C, i.e. use
		2916	/// ``@property (readonly)`` instead of ``@property(readonly)``.
		2917	/// \version 3.7
		2918	bool ObjCSpaceAfterProperty;
		2919
		2920	/// Add a space in front of an Objective-C protocol list, i.e. use
		2921	/// ``Foo <Protocol>`` instead of ``Foo<Protocol>``.
		2922	/// \version 3.7
		2923	bool ObjCSpaceBeforeProtocolList;
		2924
		2925	/// Different ways to try to fit all constructor initializers on a line.
		2926	enum PackConstructorInitializersStyle : int8_t {
		2927	/// Always put each constructor initializer on its own line.
		2928	/// \code
		2929	/// Constructor()
		2930	/// : a(),
		2931	/// b()
		2932	/// \endcode
		2933	PCIS_Never,
		2934	/// Bin-pack constructor initializers.
		2935	/// \code
		2936	/// Constructor()
		2937	/// : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(),
		2938	/// cccccccccccccccccccc()
		2939	/// \endcode
		2940	PCIS_BinPack,
		2941	/// Put all constructor initializers on the current line if they fit.
		2942	/// Otherwise, put each one on its own line.
		2943	/// \code
		2944	/// Constructor() : a(), b()
		2945	///
		2946	/// Constructor()
		2947	/// : aaaaaaaaaaaaaaaaaaaa(),
		2948	/// bbbbbbbbbbbbbbbbbbbb(),
		2949	/// ddddddddddddd()
		2950	/// \endcode
		2951	PCIS_CurrentLine,
		2952	/// Same as ``PCIS_CurrentLine`` except that if all constructor initializers
		2953	/// do not fit on the current line, try to fit them on the next line.
		2954	/// \code
		2955	/// Constructor() : a(), b()
		2956	///
		2957	/// Constructor()
		2958	/// : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), ddddddddddddd()
		2959	///
		2960	/// Constructor()
		2961	/// : aaaaaaaaaaaaaaaaaaaa(),
		2962	/// bbbbbbbbbbbbbbbbbbbb(),
		2963	/// cccccccccccccccccccc()
		2964	/// \endcode
		2965	PCIS_NextLine,
		2966	};
		2967
		2968	/// The pack constructor initializers style to use.
		2969	/// \version 14
		2970	PackConstructorInitializersStyle PackConstructorInitializers;
		2971
		2972	/// The penalty for breaking around an assignment operator.
		2973	/// \version 5
		2974	unsigned PenaltyBreakAssignment;
		2975
		2976	/// The penalty for breaking a function call after ``call(``.
		2977	/// \version 3.7
		2978	unsigned PenaltyBreakBeforeFirstCallParameter;
		2979
		2980	/// The penalty for each line break introduced inside a comment.
		2981	/// \version 3.7
		2982	unsigned PenaltyBreakComment;
		2983
		2984	/// The penalty for breaking before the first ``<<``.
		2985	/// \version 3.7
		2986	unsigned PenaltyBreakFirstLessLess;
		2987
		2988	/// The penalty for breaking after ``(``.
		2989	/// \version 14
		2990	unsigned PenaltyBreakOpenParenthesis;
		2991
		2992	/// The penalty for each line break introduced inside a string literal.
		2993	/// \version 3.7
		2994	unsigned PenaltyBreakString;
		2995
		2996	/// The penalty for breaking after template declaration.
		2997	/// \version 7
		2998	unsigned PenaltyBreakTemplateDeclaration;
		2999
		3000	/// The penalty for each character outside of the column limit.
		3001	/// \version 3.7
		3002	unsigned PenaltyExcessCharacter;
		3003
		3004	/// Penalty for each character of whitespace indentation
		3005	/// (counted relative to leading non-whitespace column).
		3006	/// \version 12
		3007	unsigned PenaltyIndentedWhitespace;
		3008
		3009	/// Penalty for putting the return type of a function onto its own line.
		3010	/// \version 3.7
		3011	unsigned PenaltyReturnTypeOnItsOwnLine;
		3012
		3013	/// The ``&``, ``&&`` and ``*`` alignment style.
		3014	enum PointerAlignmentStyle : int8_t {
		3015	/// Align pointer to the left.
		3016	/// \code
		3017	/// int* a;
		3018	/// \endcode
		3019	PAS_Left,
		3020	/// Align pointer to the right.
		3021	/// \code
		3022	/// int *a;
		3023	/// \endcode
		3024	PAS_Right,
		3025	/// Align pointer in the middle.
		3026	/// \code
		3027	/// int * a;
		3028	/// \endcode
		3029	PAS_Middle
		3030	};
		3031
		3032	/// Pointer and reference alignment style.
		3033	/// \version 3.7
		3034	PointerAlignmentStyle PointerAlignment;
		3035
		3036	/// The number of columns to use for indentation of preprocessor statements.
		3037	/// When set to -1 (default) ``IndentWidth`` is used also for preprocessor
		3038	/// statements.
		3039	/// \code
		3040	/// PPIndentWidth: 1
		3041	///
		3042	/// #ifdef __linux__
		3043	/// # define FOO
		3044	/// #else
		3045	/// # define BAR
		3046	/// #endif
		3047	/// \endcode
		3048	/// \version 13
		3049	int PPIndentWidth;
		3050
		3051	/// Different specifiers and qualifiers alignment styles.
		3052	enum QualifierAlignmentStyle : int8_t {
		3053	/// Don't change specifiers/qualifiers to either Left or Right alignment
		3054	/// (default).
		3055	/// \code
		3056	/// int const a;
		3057	/// const int *a;
		3058	/// \endcode
		3059	QAS_Leave,
		3060	/// Change specifiers/qualifiers to be left-aligned.
		3061	/// \code
		3062	/// const int a;
		3063	/// const int *a;
		3064	/// \endcode
		3065	QAS_Left,
		3066	/// Change specifiers/qualifiers to be right-aligned.
		3067	/// \code
		3068	/// int const a;
		3069	/// int const *a;
		3070	/// \endcode
		3071	QAS_Right,
		3072	/// Change specifiers/qualifiers to be aligned based on ``QualifierOrder``.
		3073	/// With:
		3074	/// \code{.yaml}
		3075	/// QualifierOrder: ['inline', 'static', 'type', 'const']
		3076	/// \endcode
		3077	///
		3078	/// \code
		3079	///
		3080	/// int const a;
		3081	/// int const *a;
		3082	/// \endcode
		3083	QAS_Custom
		3084	};
		3085
		3086	/// Different ways to arrange specifiers and qualifiers (e.g. const/volatile).
		3087	/// \warning
		3088	/// Setting ``QualifierAlignment`` to something other than `Leave`, COULD
		3089	/// lead to incorrect code formatting due to incorrect decisions made due to
		3090	/// clang-formats lack of complete semantic information.
		3091	/// As such extra care should be taken to review code changes made by the use
		3092	/// of this option.
		3093	/// \endwarning
		3094	/// \version 14
		3095	QualifierAlignmentStyle QualifierAlignment;
		3096
		3097	/// The order in which the qualifiers appear.
		3098	/// Order is an array that can contain any of the following:
		3099	///
		3100	/// * const
		3101	/// * inline
		3102	/// * static
		3103	/// * friend
		3104	/// * constexpr
		3105	/// * volatile
		3106	/// * restrict
		3107	/// * type
		3108	///
		3109	/// Note: it MUST contain 'type'.
		3110	/// Items to the left of 'type' will be placed to the left of the type and
		3111	/// aligned in the order supplied. Items to the right of 'type' will be placed
		3112	/// to the right of the type and aligned in the order supplied.
		3113	///
		3114	/// \code{.yaml}
		3115	/// QualifierOrder: ['inline', 'static', 'type', 'const', 'volatile' ]
		3116	/// \endcode
		3117	/// \version 14
		3118	std::vector<std::string> QualifierOrder;
		3119
		3120	/// See documentation of ``RawStringFormats``.
		3121	struct RawStringFormat {
		3122	/// The language of this raw string.
		3123	LanguageKind Language;
		3124	/// A list of raw string delimiters that match this language.
		3125	std::vector<std::string> Delimiters;
		3126	/// A list of enclosing function names that match this language.
		3127	std::vector<std::string> EnclosingFunctions;
		3128	/// The canonical delimiter for this language.
		3129	std::string CanonicalDelimiter;
		3130	/// The style name on which this raw string format is based on.
		3131	/// If not specified, the raw string format is based on the style that this
		3132	/// format is based on.
		3133	std::string BasedOnStyle;
		3134	bool operator==(const RawStringFormat &Other) const {
		3135	return Language == Other.Language && Delimiters == Other.Delimiters &&
		3136	EnclosingFunctions == Other.EnclosingFunctions &&
		3137	CanonicalDelimiter == Other.CanonicalDelimiter &&
		3138	BasedOnStyle == Other.BasedOnStyle;
		3139	}
		3140	};
		3141
		3142	/// Defines hints for detecting supported languages code blocks in raw
		3143	/// strings.
		3144	///
		3145	/// A raw string with a matching delimiter or a matching enclosing function
		3146	/// name will be reformatted assuming the specified language based on the
		3147	/// style for that language defined in the .clang-format file. If no style has
		3148	/// been defined in the .clang-format file for the specific language, a
		3149	/// predefined style given by 'BasedOnStyle' is used. If 'BasedOnStyle' is not
		3150	/// found, the formatting is based on llvm style. A matching delimiter takes
		3151	/// precedence over a matching enclosing function name for determining the
		3152	/// language of the raw string contents.
		3153	///
		3154	/// If a canonical delimiter is specified, occurrences of other delimiters for
		3155	/// the same language will be updated to the canonical if possible.
		3156	///
		3157	/// There should be at most one specification per language and each delimiter
		3158	/// and enclosing function should not occur in multiple specifications.
		3159	///
		3160	/// To configure this in the .clang-format file, use:
		3161	/// \code{.yaml}
		3162	/// RawStringFormats:
		3163	/// - Language: TextProto
		3164	/// Delimiters:
		3165	/// - 'pb'
		3166	/// - 'proto'
		3167	/// EnclosingFunctions:
		3168	/// - 'PARSE_TEXT_PROTO'
		3169	/// BasedOnStyle: google
		3170	/// - Language: Cpp
		3171	/// Delimiters:
		3172	/// - 'cc'
		3173	/// - 'cpp'
		3174	/// BasedOnStyle: llvm
		3175	/// CanonicalDelimiter: 'cc'
		3176	/// \endcode
		3177	/// \version 6
		3178	std::vector<RawStringFormat> RawStringFormats;
		3179
		3180	/// \brief The ``&`` and ``&&`` alignment style.
		3181	enum ReferenceAlignmentStyle : int8_t {
		3182	/// Align reference like ``PointerAlignment``.
		3183	RAS_Pointer,
		3184	/// Align reference to the left.
		3185	/// \code
		3186	/// int& a;
		3187	/// \endcode
		3188	RAS_Left,
		3189	/// Align reference to the right.
		3190	/// \code
		3191	/// int &a;
		3192	/// \endcode
		3193	RAS_Right,
		3194	/// Align reference in the middle.
		3195	/// \code
		3196	/// int & a;
		3197	/// \endcode
		3198	RAS_Middle
		3199	};
		3200
		3201	/// \brief Reference alignment style (overrides ``PointerAlignment`` for
		3202	/// references).
		3203	/// \version 13
		3204	ReferenceAlignmentStyle ReferenceAlignment;
		3205
		3206	// clang-format off
		3207	/// If ``true``, clang-format will attempt to re-flow comments. That is it
		3208	/// will touch a comment and reflow long comments into new lines, trying to
		3209	/// obey the ``ColumnLimit``.
		3210	/// \code
		3211	/// false:
		3212	/// // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
		3213	/// /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */
		3214	///
		3215	/// true:
		3216	/// // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
		3217	/// // information
		3218	/// /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
		3219	/// * information */
		3220	/// \endcode
		3221	/// \version 3.8
		3222	bool ReflowComments;
		3223	// clang-format on
		3224
		3225	/// Remove optional braces of control statements (``if``, ``else``, ``for``,
		3226	/// and ``while``) in C++ according to the LLVM coding style.
		3227	/// \warning
		3228	/// This option will be renamed and expanded to support other styles.
		3229	/// \endwarning
		3230	/// \warning
		3231	/// Setting this option to `true` could lead to incorrect code formatting due
		3232	/// to clang-format's lack of complete semantic information. As such, extra
		3233	/// care should be taken to review code changes made by this option.
		3234	/// \endwarning
		3235	/// \code
		3236	/// false: true:
		3237	///
		3238	/// if (isa<FunctionDecl>(D)) { vs. if (isa<FunctionDecl>(D))
		3239	/// handleFunctionDecl(D); handleFunctionDecl(D);
		3240	/// } else if (isa<VarDecl>(D)) { else if (isa<VarDecl>(D))
		3241	/// handleVarDecl(D); handleVarDecl(D);
		3242	/// }
		3243	///
		3244	/// if (isa<VarDecl>(D)) { vs. if (isa<VarDecl>(D)) {
		3245	/// for (auto A : D.attrs()) { for (auto A : D.attrs())
		3246	/// if (shouldProcessAttr(A)) { if (shouldProcessAttr(A))
		3247	/// handleAttr(A); handleAttr(A);
		3248	/// } }
		3249	/// }
		3250	/// }
		3251	///
		3252	/// if (isa<FunctionDecl>(D)) { vs. if (isa<FunctionDecl>(D))
		3253	/// for (auto A : D.attrs()) { for (auto A : D.attrs())
		3254	/// handleAttr(A); handleAttr(A);
		3255	/// }
		3256	/// }
		3257	///
		3258	/// if (auto D = (T)(D)) { vs. if (auto D = (T)(D)) {
		3259	/// if (shouldProcess(D)) { if (shouldProcess(D))
		3260	/// handleVarDecl(D); handleVarDecl(D);
		3261	/// } else { else
		3262	/// markAsIgnored(D); markAsIgnored(D);
		3263	/// } }
		3264	/// }
		3265	///
		3266	/// if (a) { vs. if (a)
		3267	/// b(); b();
		3268	/// } else { else if (c)
		3269	/// if (c) { d();
		3270	/// d(); else
		3271	/// } else { e();
		3272	/// e();
		3273	/// }
		3274	/// }
		3275	/// \endcode
		3276	/// \version 14
		3277	bool RemoveBracesLLVM;
		3278
		3279	/// Remove semicolons after the closing brace of a non-empty function.
		3280	/// \warning
		3281	/// Setting this option to `true` could lead to incorrect code formatting due
		3282	/// to clang-format's lack of complete semantic information. As such, extra
		3283	/// care should be taken to review code changes made by this option.
		3284	/// \endwarning
		3285	/// \code
		3286	/// false: true:
		3287	///
		3288	/// int max(int a, int b) { int max(int a, int b) {
		3289	/// return a > b ? a : b; return a > b ? a : b;
		3290	/// }; }
		3291	///
		3292	/// \endcode
		3293	/// \version 16
		3294	bool RemoveSemicolon;
		3295
		3296	/// \brief The possible positions for the requires clause. The
		3297	/// ``IndentRequires`` option is only used if the ``requires`` is put on the
		3298	/// start of a line.
		3299	enum RequiresClausePositionStyle : int8_t {
		3300	/// Always put the ``requires`` clause on its own line.
		3301	/// \code
		3302	/// template <typename T>
		3303	/// requires C<T>
		3304	/// struct Foo {...
		3305	///
		3306	/// template <typename T>
		3307	/// requires C<T>
		3308	/// void bar(T t) {...
		3309	///
		3310	/// template <typename T>
		3311	/// void baz(T t)
		3312	/// requires C<T>
		3313	/// {...
		3314	/// \endcode
		3315	RCPS_OwnLine,
		3316	/// Try to put the clause together with the preceding part of a declaration.
		3317	/// For class templates: stick to the template declaration.
		3318	/// For function templates: stick to the template declaration.
		3319	/// For function declaration followed by a requires clause: stick to the
		3320	/// parameter list.
		3321	/// \code
		3322	/// template <typename T> requires C<T>
		3323	/// struct Foo {...
		3324	///
		3325	/// template <typename T> requires C<T>
		3326	/// void bar(T t) {...
		3327	///
		3328	/// template <typename T>
		3329	/// void baz(T t) requires C<T>
		3330	/// {...
		3331	/// \endcode
		3332	RCPS_WithPreceding,
		3333	/// Try to put the ``requires`` clause together with the class or function
		3334	/// declaration.
		3335	/// \code
		3336	/// template <typename T>
		3337	/// requires C<T> struct Foo {...
		3338	///
		3339	/// template <typename T>
		3340	/// requires C<T> void bar(T t) {...
		3341	///
		3342	/// template <typename T>
		3343	/// void baz(T t)
		3344	/// requires C<T> {...
		3345	/// \endcode
		3346	RCPS_WithFollowing,
		3347	/// Try to put everything in the same line if possible. Otherwise normal
		3348	/// line breaking rules take over.
		3349	/// \code
		3350	/// // Fitting:
		3351	/// template <typename T> requires C<T> struct Foo {...
		3352	///
		3353	/// template <typename T> requires C<T> void bar(T t) {...
		3354	///
		3355	/// template <typename T> void bar(T t) requires C<T> {...
		3356	///
		3357	/// // Not fitting, one possible example:
		3358	/// template <typename LongName>
		3359	/// requires C<LongName>
		3360	/// struct Foo {...
		3361	///
		3362	/// template <typename LongName>
		3363	/// requires C<LongName>
		3364	/// void bar(LongName ln) {
		3365	///
		3366	/// template <typename LongName>
		3367	/// void bar(LongName ln)
		3368	/// requires C<LongName> {
		3369	/// \endcode
		3370	RCPS_SingleLine,
		3371	};
		3372
		3373	/// \brief The position of the ``requires`` clause.
		3374	/// \version 15
		3375	RequiresClausePositionStyle RequiresClausePosition;
		3376
		3377	/// Indentation logic for requires expression bodies.
		3378	enum RequiresExpressionIndentationKind : int8_t {
		3379	/// Align requires expression body relative to the indentation level of the
		3380	/// outer scope the requires expression resides in.
		3381	/// This is the default.
		3382	/// \code
		3383	/// template <typename T>
		3384	/// concept C = requires(T t) {
		3385	/// ...
		3386	/// }
		3387	/// \endcode
		3388	REI_OuterScope,
		3389	/// Align requires expression body relative to the `requires` keyword.
		3390	/// \code
		3391	/// template <typename T>
		3392	/// concept C = requires(T t) {
		3393	/// ...
		3394	/// }
		3395	/// \endcode
		3396	REI_Keyword,
		3397	};
		3398
		3399	/// The indentation used for requires expression bodies.
		3400	/// \version 16
		3401	RequiresExpressionIndentationKind RequiresExpressionIndentation;
		3402
		3403	/// \brief The style if definition blocks should be separated.
		3404	enum SeparateDefinitionStyle : int8_t {
		3405	/// Leave definition blocks as they are.
		3406	SDS_Leave,
		3407	/// Insert an empty line between definition blocks.
		3408	SDS_Always,
		3409	/// Remove any empty line between definition blocks.
		3410	SDS_Never
		3411	};
		3412
		3413	/// Specifies the use of empty lines to separate definition blocks, including
		3414	/// classes, structs, enums, and functions.
		3415	/// \code
		3416	/// Never v.s. Always
		3417	/// #include <cstring> #include <cstring>
		3418	/// struct Foo {
		3419	/// int a, b, c; struct Foo {
		3420	/// }; int a, b, c;
		3421	/// namespace Ns { };
		3422	/// class Bar {
		3423	/// public: namespace Ns {
		3424	/// struct Foobar { class Bar {
		3425	/// int a; public:
		3426	/// int b; struct Foobar {
		3427	/// }; int a;
		3428	/// private: int b;
		3429	/// int t; };
		3430	/// int method1() {
		3431	/// // ... private:
		3432	/// } int t;
		3433	/// enum List {
		3434	/// ITEM1, int method1() {
		3435	/// ITEM2 // ...
		3436	/// }; }
		3437	/// template<typename T>
		3438	/// int method2(T x) { enum List {
		3439	/// // ... ITEM1,
		3440	/// } ITEM2
		3441	/// int i, j, k; };
		3442	/// int method3(int par) {
		3443	/// // ... template<typename T>
		3444	/// } int method2(T x) {
		3445	/// }; // ...
		3446	/// class C {}; }
		3447	/// }
		3448	/// int i, j, k;
		3449	///
		3450	/// int method3(int par) {
		3451	/// // ...
		3452	/// }
		3453	/// };
		3454	///
		3455	/// class C {};
		3456	/// }
		3457	/// \endcode
		3458	/// \version 14
		3459	SeparateDefinitionStyle SeparateDefinitionBlocks;
		3460
		3461	/// The maximal number of unwrapped lines that a short namespace spans.
		3462	/// Defaults to 1.
		3463	///
		3464	/// This determines the maximum length of short namespaces by counting
		3465	/// unwrapped lines (i.e. containing neither opening nor closing
		3466	/// namespace brace) and makes "FixNamespaceComments" omit adding
		3467	/// end comments for those.
		3468	/// \code
		3469	/// ShortNamespaceLines: 1 vs. ShortNamespaceLines: 0
		3470	/// namespace a { namespace a {
		3471	/// int foo; int foo;
		3472	/// } } // namespace a
		3473	///
		3474	/// ShortNamespaceLines: 1 vs. ShortNamespaceLines: 0
		3475	/// namespace b { namespace b {
		3476	/// int foo; int foo;
		3477	/// int bar; int bar;
		3478	/// } // namespace b } // namespace b
		3479	/// \endcode
		3480	/// \version 13
		3481	unsigned ShortNamespaceLines;
		3482
		3483	/// Include sorting options.
		3484	enum SortIncludesOptions : int8_t {
		3485	/// Includes are never sorted.
		3486	/// \code
		3487	/// #include "B/A.h"
		3488	/// #include "A/B.h"
		3489	/// #include "a/b.h"
		3490	/// #include "A/b.h"
		3491	/// #include "B/a.h"
		3492	/// \endcode
		3493	SI_Never,
		3494	/// Includes are sorted in an ASCIIbetical or case sensitive fashion.
		3495	/// \code
		3496	/// #include "A/B.h"
		3497	/// #include "A/b.h"
		3498	/// #include "B/A.h"
		3499	/// #include "B/a.h"
		3500	/// #include "a/b.h"
		3501	/// \endcode
		3502	SI_CaseSensitive,
		3503	/// Includes are sorted in an alphabetical or case insensitive fashion.
		3504	/// \code
		3505	/// #include "A/B.h"
		3506	/// #include "A/b.h"
		3507	/// #include "a/b.h"
		3508	/// #include "B/A.h"
		3509	/// #include "B/a.h"
		3510	/// \endcode
		3511	SI_CaseInsensitive,
		3512	};
		3513
		3514	/// Controls if and how clang-format will sort ``#includes``.
		3515	/// If ``Never``, includes are never sorted.
		3516	/// If ``CaseInsensitive``, includes are sorted in an ASCIIbetical or case
		3517	/// insensitive fashion.
		3518	/// If ``CaseSensitive``, includes are sorted in an alphabetical or case
		3519	/// sensitive fashion.
		3520	/// \version 3.8
		3521	SortIncludesOptions SortIncludes;
		3522
		3523	/// Position for Java Static imports.
		3524	enum SortJavaStaticImportOptions : int8_t {
		3525	/// Static imports are placed before non-static imports.
		3526	/// \code{.java}
		3527	/// import static org.example.function1;
		3528	///
		3529	/// import org.example.ClassA;
		3530	/// \endcode
		3531	SJSIO_Before,
		3532	/// Static imports are placed after non-static imports.
		3533	/// \code{.java}
		3534	/// import org.example.ClassA;
		3535	///
		3536	/// import static org.example.function1;
		3537	/// \endcode
		3538	SJSIO_After,
		3539	};
		3540
		3541	/// When sorting Java imports, by default static imports are placed before
		3542	/// non-static imports. If ``JavaStaticImportAfterImport`` is ``After``,
		3543	/// static imports are placed after non-static imports.
		3544	/// \version 12
		3545	SortJavaStaticImportOptions SortJavaStaticImport;
		3546
		3547	/// Using declaration sorting options.
		3548	enum SortUsingDeclarationsOptions : int8_t {
		3549	/// Using declarations are never sorted.
		3550	/// \code
		3551	/// using std::chrono::duration_cast;
		3552	/// using std::move;
		3553	/// using boost::regex;
		3554	/// using boost::regex_constants::icase;
		3555	/// using std::string;
		3556	/// \endcode
		3557	SUD_Never,
		3558	/// Using declarations are sorted in the order defined as follows:
		3559	/// Split the strings by "::" and discard any initial empty strings. Sort
		3560	/// the lists of names lexicographically, and within those groups, names are
		3561	/// in case-insensitive lexicographic order.
		3562	/// \code
		3563	/// using boost::regex;
		3564	/// using boost::regex_constants::icase;
		3565	/// using std::chrono::duration_cast;
		3566	/// using std::move;
		3567	/// using std::string;
		3568	/// \endcode
		3569	SUD_Lexicographic,
		3570	/// Using declarations are sorted in the order defined as follows:
		3571	/// Split the strings by "::" and discard any initial empty strings. The
		3572	/// last element of each list is a non-namespace name; all others are
		3573	/// namespace names. Sort the lists of names lexicographically, where the
		3574	/// sort order of individual names is that all non-namespace names come
		3575	/// before all namespace names, and within those groups, names are in
		3576	/// case-insensitive lexicographic order.
		3577	/// \code
		3578	/// using boost::regex;
		3579	/// using boost::regex_constants::icase;
		3580	/// using std::move;
		3581	/// using std::string;
		3582	/// using std::chrono::duration_cast;
		3583	/// \endcode
		3584	SUD_LexicographicNumeric,
		3585	};
		3586
		3587	/// Controls if and how clang-format will sort using declarations.
		3588	/// \version 5
		3589	SortUsingDeclarationsOptions SortUsingDeclarations;
		3590
		3591	/// If ``true``, a space is inserted after C style casts.
		3592	/// \code
		3593	/// true: false:
		3594	/// (int) i; vs. (int)i;
		3595	/// \endcode
		3596	/// \version 3.5
		3597	bool SpaceAfterCStyleCast;
		3598
		3599	/// If ``true``, a space is inserted after the logical not operator (``!``).
		3600	/// \code
		3601	/// true: false:
		3602	/// ! someExpression(); vs. !someExpression();
		3603	/// \endcode
		3604	/// \version 9
		3605	bool SpaceAfterLogicalNot;
		3606
		3607	/// If \c true, a space will be inserted after the 'template' keyword.
		3608	/// \code
		3609	/// true: false:
		3610	/// template <int> void foo(); vs. template<int> void foo();
		3611	/// \endcode
		3612	/// \version 4
		3613	bool SpaceAfterTemplateKeyword;
		3614
		3615	/// Different ways to put a space before opening parentheses.
		3616	enum SpaceAroundPointerQualifiersStyle : int8_t {
		3617	/// Don't ensure spaces around pointer qualifiers and use PointerAlignment
		3618	/// instead.
		3619	/// \code
		3620	/// PointerAlignment: Left PointerAlignment: Right
		3621	/// void* const* x = NULL; vs. void const x = NULL;
		3622	/// \endcode
		3623	SAPQ_Default,
		3624	/// Ensure that there is a space before pointer qualifiers.
		3625	/// \code
		3626	/// PointerAlignment: Left PointerAlignment: Right
		3627	/// void* const* x = NULL; vs. void * const *x = NULL;
		3628	/// \endcode
		3629	SAPQ_Before,
		3630	/// Ensure that there is a space after pointer qualifiers.
		3631	/// \code
		3632	/// PointerAlignment: Left PointerAlignment: Right
		3633	/// void* const * x = NULL; vs. void const x = NULL;
		3634	/// \endcode
		3635	SAPQ_After,
		3636	/// Ensure that there is a space both before and after pointer qualifiers.
		3637	/// \code
		3638	/// PointerAlignment: Left PointerAlignment: Right
		3639	/// void* const * x = NULL; vs. void * const *x = NULL;
		3640	/// \endcode
		3641	SAPQ_Both,
		3642	};
		3643
		3644	/// Defines in which cases to put a space before or after pointer qualifiers
		3645	/// \version 12
		3646	SpaceAroundPointerQualifiersStyle SpaceAroundPointerQualifiers;
		3647
		3648	/// If ``false``, spaces will be removed before assignment operators.
		3649	/// \code
		3650	/// true: false:
		3651	/// int a = 5; vs. int a= 5;
		3652	/// a += 42; a+= 42;
		3653	/// \endcode
		3654	/// \version 3.7
		3655	bool SpaceBeforeAssignmentOperators;
		3656
		3657	/// If ``false``, spaces will be removed before case colon.
		3658	/// \code
		3659	/// true: false
		3660	/// switch (x) { vs. switch (x) {
		3661	/// case 1 : break; case 1: break;
		3662	/// } }
		3663	/// \endcode
		3664	/// \version 12
		3665	bool SpaceBeforeCaseColon;
		3666
		3667	/// If ``true``, a space will be inserted before a C++11 braced list
		3668	/// used to initialize an object (after the preceding identifier or type).
		3669	/// \code
		3670	/// true: false:
		3671	/// Foo foo { bar }; vs. Foo foo{ bar };
		3672	/// Foo {}; Foo{};
		3673	/// vector<int> { 1, 2, 3 }; vector<int>{ 1, 2, 3 };
		3674	/// new int[3] { 1, 2, 3 }; new int[3]{ 1, 2, 3 };
		3675	/// \endcode
		3676	/// \version 7
		3677	bool SpaceBeforeCpp11BracedList;
		3678
		3679	/// If ``false``, spaces will be removed before constructor initializer
		3680	/// colon.
		3681	/// \code
		3682	/// true: false:
		3683	/// Foo::Foo() : a(a) {} Foo::Foo(): a(a) {}
		3684	/// \endcode
		3685	/// \version 7
		3686	bool SpaceBeforeCtorInitializerColon;
		3687
		3688	/// If ``false``, spaces will be removed before inheritance colon.
		3689	/// \code
		3690	/// true: false:
		3691	/// class Foo : Bar {} vs. class Foo: Bar {}
		3692	/// \endcode
		3693	/// \version 7
		3694	bool SpaceBeforeInheritanceColon;
		3695
		3696	/// Different ways to put a space before opening parentheses.
		3697	enum SpaceBeforeParensStyle : int8_t {
		3698	/// Never put a space before opening parentheses.
		3699	/// \code
		3700	/// void f() {
		3701	/// if(true) {
		3702	/// f();
		3703	/// }
		3704	/// }
		3705	/// \endcode
		3706	SBPO_Never,
		3707	/// Put a space before opening parentheses only after control statement
		3708	/// keywords (``for/if/while...``).
		3709	/// \code
		3710	/// void f() {
		3711	/// if (true) {
		3712	/// f();
		3713	/// }
		3714	/// }
		3715	/// \endcode
		3716	SBPO_ControlStatements,
		3717	/// Same as ``SBPO_ControlStatements`` except this option doesn't apply to
		3718	/// ForEach and If macros. This is useful in projects where ForEach/If
		3719	/// macros are treated as function calls instead of control statements.
		3720	/// ``SBPO_ControlStatementsExceptForEachMacros`` remains an alias for
		3721	/// backward compatibility.
		3722	/// \code
		3723	/// void f() {
		3724	/// Q_FOREACH(...) {
		3725	/// f();
		3726	/// }
		3727	/// }
		3728	/// \endcode
		3729	SBPO_ControlStatementsExceptControlMacros,
		3730	/// Put a space before opening parentheses only if the parentheses are not
		3731	/// empty i.e. '()'
		3732	/// \code
		3733	/// void() {
		3734	/// if (true) {
		3735	/// f();
		3736	/// g (x, y, z);
		3737	/// }
		3738	/// }
		3739	/// \endcode
		3740	SBPO_NonEmptyParentheses,
		3741	/// Always put a space before opening parentheses, except when it's
		3742	/// prohibited by the syntax rules (in function-like macro definitions) or
		3743	/// when determined by other style rules (after unary operators, opening
		3744	/// parentheses, etc.)
		3745	/// \code
		3746	/// void f () {
		3747	/// if (true) {
		3748	/// f ();
		3749	/// }
		3750	/// }
		3751	/// \endcode
		3752	SBPO_Always,
		3753	/// Configure each individual space before parentheses in
		3754	/// `SpaceBeforeParensOptions`.
		3755	SBPO_Custom,
		3756	};
		3757
		3758	/// Defines in which cases to put a space before opening parentheses.
		3759	/// \version 3.5
		3760	SpaceBeforeParensStyle SpaceBeforeParens;
		3761
		3762	/// Precise control over the spacing before parentheses.
		3763	/// \code
		3764	/// # Should be declared this way:
		3765	/// SpaceBeforeParens: Custom
		3766	/// SpaceBeforeParensOptions:
		3767	/// AfterControlStatements: true
		3768	/// AfterFunctionDefinitionName: true
		3769	/// \endcode
		3770	struct SpaceBeforeParensCustom {
		3771	/// If ``true``, put space betwee control statement keywords
		3772	/// (for/if/while...) and opening parentheses.
		3773	/// \code
		3774	/// true: false:
		3775	/// if (...) {} vs. if(...) {}
		3776	/// \endcode
		3777	bool AfterControlStatements;
		3778	/// If ``true``, put space between foreach macros and opening parentheses.
		3779	/// \code
		3780	/// true: false:
		3781	/// FOREACH (...) vs. FOREACH(...)
		3782	/// <loop-body> <loop-body>
		3783	/// \endcode
		3784	bool AfterForeachMacros;
		3785	/// If ``true``, put a space between function declaration name and opening
		3786	/// parentheses.
		3787	/// \code
		3788	/// true: false:
		3789	/// void f (); vs. void f();
		3790	/// \endcode
		3791	bool AfterFunctionDeclarationName;
		3792	/// If ``true``, put a space between function definition name and opening
		3793	/// parentheses.
		3794	/// \code
		3795	/// true: false:
		3796	/// void f () {} vs. void f() {}
		3797	/// \endcode
		3798	bool AfterFunctionDefinitionName;
		3799	/// If ``true``, put space between if macros and opening parentheses.
		3800	/// \code
		3801	/// true: false:
		3802	/// IF (...) vs. IF(...)
		3803	/// <conditional-body> <conditional-body>
		3804	/// \endcode
		3805	bool AfterIfMacros;
		3806	/// If ``true``, put a space between operator overloading and opening
		3807	/// parentheses.
		3808	/// \code
		3809	/// true: false:
		3810	/// void operator++ (int a); vs. void operator++(int a);
		3811	/// object.operator++ (10); object.operator++(10);
		3812	/// \endcode
		3813	bool AfterOverloadedOperator;
		3814	/// If ``true``, put space between requires keyword in a requires clause and
		3815	/// opening parentheses, if there is one.
		3816	/// \code
		3817	/// true: false:
		3818	/// template<typename T> vs. template<typename T>
		3819	/// requires (A<T> && B<T>) requires(A<T> && B<T>)
		3820	/// ... ...
		3821	/// \endcode
		3822	bool AfterRequiresInClause;
		3823	/// If ``true``, put space between requires keyword in a requires expression
		3824	/// and opening parentheses.
		3825	/// \code
		3826	/// true: false:
		3827	/// template<typename T> vs. template<typename T>
		3828	/// concept C = requires (T t) { concept C = requires(T t) {
		3829	/// ... ...
		3830	/// } }
		3831	/// \endcode
		3832	bool AfterRequiresInExpression;
		3833	/// If ``true``, put a space before opening parentheses only if the
		3834	/// parentheses are not empty.
		3835	/// \code
		3836	/// true: false:
		3837	/// void f (int a); vs. void f();
		3838	/// f (a); f();
		3839	/// \endcode
		3840	bool BeforeNonEmptyParentheses;
		3841
		3842	SpaceBeforeParensCustom()
		3843	: AfterControlStatements(false), AfterForeachMacros(false),
		3844	AfterFunctionDeclarationName(false),
		3845	AfterFunctionDefinitionName(false), AfterIfMacros(false),
		3846	AfterOverloadedOperator(false), AfterRequiresInClause(false),
		3847	AfterRequiresInExpression(false), BeforeNonEmptyParentheses(false) {}
		3848
		3849	bool operator==(const SpaceBeforeParensCustom &Other) const {
		3850	return AfterControlStatements == Other.AfterControlStatements &&
		3851	AfterForeachMacros == Other.AfterForeachMacros &&
		3852	AfterFunctionDeclarationName ==
		3853	Other.AfterFunctionDeclarationName &&
		3854	AfterFunctionDefinitionName == Other.AfterFunctionDefinitionName &&
		3855	AfterIfMacros == Other.AfterIfMacros &&
		3856	AfterOverloadedOperator == Other.AfterOverloadedOperator &&
		3857	AfterRequiresInClause == Other.AfterRequiresInClause &&
		3858	AfterRequiresInExpression == Other.AfterRequiresInExpression &&
		3859	BeforeNonEmptyParentheses == Other.BeforeNonEmptyParentheses;
		3860	}
		3861	};
		3862
		3863	/// Control of individual space before parentheses.
		3864	///
		3865	/// If ``SpaceBeforeParens`` is set to ``Custom``, use this to specify
		3866	/// how each individual space before parentheses case should be handled.
		3867	/// Otherwise, this is ignored.
		3868	/// \code{.yaml}
		3869	/// # Example of usage:
		3870	/// SpaceBeforeParens: Custom
		3871	/// SpaceBeforeParensOptions:
		3872	/// AfterControlStatements: true
		3873	/// AfterFunctionDefinitionName: true
		3874	/// \endcode
		3875	/// \version 14
		3876	SpaceBeforeParensCustom SpaceBeforeParensOptions;
		3877
		3878	/// If ``true``, spaces will be before ``[``.
		3879	/// Lambdas will not be affected. Only the first ``[`` will get a space added.
		3880	/// \code
		3881	/// true: false:
		3882	/// int a [5]; vs. int a[5];
		3883	/// int a [5][5]; vs. int a[5][5];
		3884	/// \endcode
		3885	/// \version 10
		3886	bool SpaceBeforeSquareBrackets;
		3887
		3888	/// If ``false``, spaces will be removed before range-based for loop
		3889	/// colon.
		3890	/// \code
		3891	/// true: false:
		3892	/// for (auto v : values) {} vs. for(auto v: values) {}
		3893	/// \endcode
		3894	/// \version 7
		3895	bool SpaceBeforeRangeBasedForLoopColon;
		3896
		3897	/// If ``true``, spaces will be inserted into ``{}``.
		3898	/// \code
		3899	/// true: false:
		3900	/// void f() { } vs. void f() {}
		3901	/// while (true) { } while (true) {}
		3902	/// \endcode
		3903	/// \version 10
		3904	bool SpaceInEmptyBlock;
		3905
		3906	/// If ``true``, spaces may be inserted into ``()``.
		3907	/// \code
		3908	/// true: false:
		3909	/// void f( ) { vs. void f() {
		3910	/// int x[] = {foo( ), bar( )}; int x[] = {foo(), bar()};
		3911	/// if (true) { if (true) {
		3912	/// f( ); f();
		3913	/// } }
		3914	/// } }
		3915	/// \endcode
		3916	/// \version 3.7
		3917	bool SpaceInEmptyParentheses;
		3918
		3919	/// The number of spaces before trailing line comments
		3920	/// (``//`` - comments).
		3921	///
		3922	/// This does not affect trailing block comments (``/*`` - comments) as
		3923	/// those commonly have different usage patterns and a number of special
		3924	/// cases.
		3925	/// \code
		3926	/// SpacesBeforeTrailingComments: 3
		3927	/// void f() {
		3928	/// if (true) { // foo1
		3929	/// f(); // bar
		3930	/// } // foo
		3931	/// }
		3932	/// \endcode
		3933	/// \version 3.7
		3934	unsigned SpacesBeforeTrailingComments;
		3935
		3936	/// Styles for adding spacing after ``<`` and before ``>`
		3937	/// in template argument lists.
		3938	enum SpacesInAnglesStyle : int8_t {
		3939	/// Remove spaces after ``<`` and before ``>``.
		3940	/// \code
		3941	/// static_cast<int>(arg);
		3942	/// std::function<void(int)> fct;
		3943	/// \endcode
		3944	SIAS_Never,
		3945	/// Add spaces after ``<`` and before ``>``.
		3946	/// \code
		3947	/// static_cast< int >(arg);
		3948	/// std::function< void(int) > fct;
		3949	/// \endcode
		3950	SIAS_Always,
		3951	/// Keep a single space after ``<`` and before ``>`` if any spaces were
		3952	/// present. Option ``Standard: Cpp03`` takes precedence.
		3953	SIAS_Leave
		3954	};
		3955	/// The SpacesInAnglesStyle to use for template argument lists.
		3956	/// \version 3.4
		3957	SpacesInAnglesStyle SpacesInAngles;
		3958
		3959	/// If ``true``, spaces will be inserted around if/for/switch/while
		3960	/// conditions.
		3961	/// \code
		3962	/// true: false:
		3963	/// if ( a ) { ... } vs. if (a) { ... }
		3964	/// while ( i < 5 ) { ... } while (i < 5) { ... }
		3965	/// \endcode
		3966	/// \version 10
		3967	bool SpacesInConditionalStatement;
		3968
		3969	/// If ``true``, spaces are inserted inside container literals (e.g.
		3970	/// ObjC and Javascript array and dict literals).
		3971	/// \code{.js}
		3972	/// true: false:
		3973	/// var arr = [ 1, 2, 3 ]; vs. var arr = [1, 2, 3];
		3974	/// f({a : 1, b : 2, c : 3}); f({a: 1, b: 2, c: 3});
		3975	/// \endcode
		3976	/// \version 3.7
		3977	bool SpacesInContainerLiterals;
		3978
		3979	/// If ``true``, spaces may be inserted into C style casts.
		3980	/// \code
		3981	/// true: false:
		3982	/// x = ( int32 )y vs. x = (int32)y
		3983	/// \endcode
		3984	/// \version 3.7
		3985	bool SpacesInCStyleCastParentheses;
		3986
		3987	/// Control of spaces within a single line comment.
		3988	struct SpacesInLineComment {
		3989	/// The minimum number of spaces at the start of the comment.
		3990	unsigned Minimum;
		3991	/// The maximum number of spaces at the start of the comment.
		3992	unsigned Maximum;
		3993	};
		3994
		3995	/// How many spaces are allowed at the start of a line comment. To disable the
		3996	/// maximum set it to ``-1``, apart from that the maximum takes precedence
		3997	/// over the minimum.
		3998	/// \code
		3999	/// Minimum = 1
		4000	/// Maximum = -1
		4001	/// // One space is forced
		4002	///
		4003	/// // but more spaces are possible
		4004	///
		4005	/// Minimum = 0
		4006	/// Maximum = 0
		4007	/// //Forces to start every comment directly after the slashes
		4008	/// \endcode
		4009	///
		4010	/// Note that in line comment sections the relative indent of the subsequent
		4011	/// lines is kept, that means the following:
		4012	/// \code
		4013	/// before: after:
		4014	/// Minimum: 1
		4015	/// //if (b) { // if (b) {
		4016	/// // return true; // return true;
		4017	/// //} // }
		4018	///
		4019	/// Maximum: 0
		4020	/// /// List: ///List:
		4021	/// /// - Foo /// - Foo
		4022	/// /// - Bar /// - Bar
		4023	/// \endcode
		4024	///
		4025	/// This option has only effect if ``ReflowComments`` is set to ``true``.
		4026	/// \version 13
		4027	SpacesInLineComment SpacesInLineCommentPrefix;
		4028
		4029	/// If ``true``, spaces will be inserted after ``(`` and before ``)``.
		4030	/// \code
		4031	/// true: false:
		4032	/// t f( Deleted & ) & = delete; vs. t f(Deleted &) & = delete;
		4033	/// \endcode
		4034	/// \version 3.7
		4035	bool SpacesInParentheses;
		4036
		4037	/// If ``true``, spaces will be inserted after ``[`` and before ``]``.
		4038	/// Lambdas without arguments or unspecified size array declarations will not
		4039	/// be affected.
		4040	/// \code
		4041	/// true: false:
		4042	/// int a[ 5 ]; vs. int a[5];
		4043	/// std::unique_ptr<int[]> foo() {} // Won't be affected
		4044	/// \endcode
		4045	/// \version 3.7
		4046	bool SpacesInSquareBrackets;
		4047
		4048	/// Supported language standards for parsing and formatting C++ constructs.
		4049	/// \code
		4050	/// Latest: vector<set<int>>
		4051	/// c++03 vs. vector<set<int> >
		4052	/// \endcode
		4053	///
		4054	/// The correct way to spell a specific language version is e.g. ``c++11``.
		4055	/// The historical aliases ``Cpp03`` and ``Cpp11`` are deprecated.
		4056	enum LanguageStandard : int8_t {
		4057	/// Parse and format as C++03.
		4058	/// ``Cpp03`` is a deprecated alias for ``c++03``
		4059	LS_Cpp03, // c++03
		4060	/// Parse and format as C++11.
		4061	LS_Cpp11, // c++11
		4062	/// Parse and format as C++14.
		4063	LS_Cpp14, // c++14
		4064	/// Parse and format as C++17.
		4065	LS_Cpp17, // c++17
		4066	/// Parse and format as C++20.
		4067	LS_Cpp20, // c++20
		4068	/// Parse and format using the latest supported language version.
		4069	/// ``Cpp11`` is a deprecated alias for ``Latest``
		4070	LS_Latest,
		4071	/// Automatic detection based on the input.
		4072	LS_Auto,
		4073	};
		4074
		4075	/// Parse and format C++ constructs compatible with this standard.
		4076	/// \code
		4077	/// c++03: latest:
		4078	/// vector<set<int> > x; vs. vector<set<int>> x;
		4079	/// \endcode
		4080	/// \version 3.7
		4081	LanguageStandard Standard;
		4082
		4083	/// Macros which are ignored in front of a statement, as if they were an
		4084	/// attribute. So that they are not parsed as identifier, for example for Qts
		4085	/// emit.
		4086	/// \code
		4087	/// AlignConsecutiveDeclarations: true
		4088	/// StatementAttributeLikeMacros: []
		4089	/// unsigned char data = 'x';
		4090	/// emit signal(data); // This is parsed as variable declaration.
		4091	///
		4092	/// AlignConsecutiveDeclarations: true
		4093	/// StatementAttributeLikeMacros: [emit]
		4094	/// unsigned char data = 'x';
		4095	/// emit signal(data); // Now it's fine again.
		4096	/// \endcode
		4097	/// \version 12
		4098	std::vector<std::string> StatementAttributeLikeMacros;
		4099
		4100	/// A vector of macros that should be interpreted as complete
		4101	/// statements.
		4102	///
		4103	/// Typical macros are expressions, and require a semi-colon to be
		4104	/// added; sometimes this is not the case, and this allows to make
		4105	/// clang-format aware of such cases.
		4106	///
		4107	/// For example: Q_UNUSED
		4108	/// \version 8
		4109	std::vector<std::string> StatementMacros;
		4110
		4111	/// The number of columns used for tab stops.
		4112	/// \version 3.7
		4113	unsigned TabWidth;
		4114
		4115	/// \brief A vector of macros that should be interpreted as type declarations
		4116	/// instead of as function calls.
		4117	///
		4118	/// These are expected to be macros of the form:
		4119	/// \code
		4120	/// STACK_OF(...)
		4121	/// \endcode
		4122	///
		4123	/// In the .clang-format configuration file, this can be configured like:
		4124	/// \code{.yaml}
		4125	/// TypenameMacros: ['STACK_OF', 'LIST']
		4126	/// \endcode
		4127	///
		4128	/// For example: OpenSSL STACK_OF, BSD LIST_ENTRY.
		4129	/// \version 9
		4130	std::vector<std::string> TypenameMacros;
		4131
		4132	/// This option is deprecated. See ``LF`` and ``CRLF`` of ``LineEnding``.
		4133	/// \version 10
		4134	// bool UseCRLF;
		4135
		4136	/// Different ways to use tab in formatting.
		4137	enum UseTabStyle : int8_t {
		4138	/// Never use tab.
		4139	UT_Never,
		4140	/// Use tabs only for indentation.
		4141	UT_ForIndentation,
		4142	/// Fill all leading whitespace with tabs, and use spaces for alignment that
		4143	/// appears within a line (e.g. consecutive assignments and declarations).
		4144	UT_ForContinuationAndIndentation,
		4145	/// Use tabs for line continuation and indentation, and spaces for
		4146	/// alignment.
		4147	UT_AlignWithSpaces,
		4148	/// Use tabs whenever we need to fill whitespace that spans at least from
		4149	/// one tab stop to the next one.
		4150	UT_Always
		4151	};
		4152
		4153	/// The way to use tab characters in the resulting file.
		4154	/// \version 3.7
		4155	UseTabStyle UseTab;
		4156
		4157	/// A vector of macros which are whitespace-sensitive and should not
		4158	/// be touched.
		4159	///
		4160	/// These are expected to be macros of the form:
		4161	/// \code
		4162	/// STRINGIZE(...)
		4163	/// \endcode
		4164	///
		4165	/// In the .clang-format configuration file, this can be configured like:
		4166	/// \code{.yaml}
		4167	/// WhitespaceSensitiveMacros: ['STRINGIZE', 'PP_STRINGIZE']
		4168	/// \endcode
		4169	///
		4170	/// For example: BOOST_PP_STRINGIZE
		4171	/// \version 11
		4172	std::vector<std::string> WhitespaceSensitiveMacros;
		4173
		4174	bool operator==(const FormatStyle &R) const {
		4175	return AccessModifierOffset == R.AccessModifierOffset &&
		4176	AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
		4177	AlignArrayOfStructures == R.AlignArrayOfStructures &&
		4178	AlignConsecutiveAssignments == R.AlignConsecutiveAssignments &&
		4179	AlignConsecutiveBitFields == R.AlignConsecutiveBitFields &&
		4180	AlignConsecutiveDeclarations == R.AlignConsecutiveDeclarations &&
		4181	AlignConsecutiveMacros == R.AlignConsecutiveMacros &&
		4182	AlignEscapedNewlines == R.AlignEscapedNewlines &&
		4183	AlignOperands == R.AlignOperands &&
		4184	AlignTrailingComments == R.AlignTrailingComments &&
		4185	AllowAllArgumentsOnNextLine == R.AllowAllArgumentsOnNextLine &&
		4186	AllowAllParametersOfDeclarationOnNextLine ==
		4187	R.AllowAllParametersOfDeclarationOnNextLine &&
		4188	AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine &&
		4189	AllowShortCaseLabelsOnASingleLine ==
		4190	R.AllowShortCaseLabelsOnASingleLine &&
		4191	AllowShortEnumsOnASingleLine == R.AllowShortEnumsOnASingleLine &&
		4192	AllowShortFunctionsOnASingleLine ==
		4193	R.AllowShortFunctionsOnASingleLine &&
		4194	AllowShortIfStatementsOnASingleLine ==
		4195	R.AllowShortIfStatementsOnASingleLine &&
		4196	AllowShortLambdasOnASingleLine == R.AllowShortLambdasOnASingleLine &&
		4197	AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine &&
		4198	AlwaysBreakAfterReturnType == R.AlwaysBreakAfterReturnType &&
		4199	AlwaysBreakBeforeMultilineStrings ==
		4200	R.AlwaysBreakBeforeMultilineStrings &&
		4201	AlwaysBreakTemplateDeclarations ==
		4202	R.AlwaysBreakTemplateDeclarations &&
		4203	AttributeMacros == R.AttributeMacros &&
		4204	BinPackArguments == R.BinPackArguments &&
		4205	BinPackParameters == R.BinPackParameters &&
		4206	BitFieldColonSpacing == R.BitFieldColonSpacing &&
		4207	BreakAfterAttributes == R.BreakAfterAttributes &&
		4208	BreakAfterJavaFieldAnnotations == R.BreakAfterJavaFieldAnnotations &&
		4209	BreakArrays == R.BreakArrays &&
		4210	BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators &&
		4211	BreakBeforeBraces == R.BreakBeforeBraces &&
		4212	BreakBeforeConceptDeclarations == R.BreakBeforeConceptDeclarations &&
		4213	BreakBeforeInlineASMColon == R.BreakBeforeInlineASMColon &&
		4214	BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators &&
		4215	BreakConstructorInitializers == R.BreakConstructorInitializers &&
		4216	BreakInheritanceList == R.BreakInheritanceList &&
		4217	BreakStringLiterals == R.BreakStringLiterals &&
		4218	ColumnLimit == R.ColumnLimit && CommentPragmas == R.CommentPragmas &&
		4219	CompactNamespaces == R.CompactNamespaces &&
		4220	ConstructorInitializerIndentWidth ==
		4221	R.ConstructorInitializerIndentWidth &&
		4222	ContinuationIndentWidth == R.ContinuationIndentWidth &&
		4223	Cpp11BracedListStyle == R.Cpp11BracedListStyle &&
		4224	DerivePointerAlignment == R.DerivePointerAlignment &&
		4225	DisableFormat == R.DisableFormat &&
		4226	EmptyLineAfterAccessModifier == R.EmptyLineAfterAccessModifier &&
		4227	EmptyLineBeforeAccessModifier == R.EmptyLineBeforeAccessModifier &&
		4228	ExperimentalAutoDetectBinPacking ==
		4229	R.ExperimentalAutoDetectBinPacking &&
		4230	FixNamespaceComments == R.FixNamespaceComments &&
		4231	ForEachMacros == R.ForEachMacros &&
		4232	IncludeStyle.IncludeBlocks == R.IncludeStyle.IncludeBlocks &&
		4233	IncludeStyle.IncludeCategories == R.IncludeStyle.IncludeCategories &&
		4234	IncludeStyle.IncludeIsMainRegex ==
		4235	R.IncludeStyle.IncludeIsMainRegex &&
		4236	IncludeStyle.IncludeIsMainSourceRegex ==
		4237	R.IncludeStyle.IncludeIsMainSourceRegex &&
		4238	IndentAccessModifiers == R.IndentAccessModifiers &&
		4239	IndentCaseBlocks == R.IndentCaseBlocks &&
		4240	IndentCaseLabels == R.IndentCaseLabels &&
		4241	IndentExternBlock == R.IndentExternBlock &&
		4242	IndentGotoLabels == R.IndentGotoLabels &&
		4243	IndentPPDirectives == R.IndentPPDirectives &&
		4244	IndentRequiresClause == R.IndentRequiresClause &&
		4245	IndentWidth == R.IndentWidth &&
		4246	IndentWrappedFunctionNames == R.IndentWrappedFunctionNames &&
		4247	InsertBraces == R.InsertBraces &&
		4248	InsertNewlineAtEOF == R.InsertNewlineAtEOF &&
		4249	IntegerLiteralSeparator == R.IntegerLiteralSeparator &&
		4250	JavaImportGroups == R.JavaImportGroups &&
		4251	JavaScriptQuotes == R.JavaScriptQuotes &&
		4252	JavaScriptWrapImports == R.JavaScriptWrapImports &&
		4253	KeepEmptyLinesAtTheStartOfBlocks ==
		4254	R.KeepEmptyLinesAtTheStartOfBlocks &&
		4255	Language == R.Language &&
		4256	LambdaBodyIndentation == R.LambdaBodyIndentation &&
		4257	LineEnding == R.LineEnding && MacroBlockBegin == R.MacroBlockBegin &&
		4258	MacroBlockEnd == R.MacroBlockEnd &&
		4259	MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep &&
		4260	NamespaceIndentation == R.NamespaceIndentation &&
		4261	NamespaceMacros == R.NamespaceMacros &&
		4262	ObjCBinPackProtocolList == R.ObjCBinPackProtocolList &&
		4263	ObjCBlockIndentWidth == R.ObjCBlockIndentWidth &&
		4264	ObjCBreakBeforeNestedBlockParam ==
		4265	R.ObjCBreakBeforeNestedBlockParam &&
		4266	ObjCSpaceAfterProperty == R.ObjCSpaceAfterProperty &&
		4267	ObjCSpaceBeforeProtocolList == R.ObjCSpaceBeforeProtocolList &&
		4268	PackConstructorInitializers == R.PackConstructorInitializers &&
		4269	PenaltyBreakAssignment == R.PenaltyBreakAssignment &&
		4270	PenaltyBreakBeforeFirstCallParameter ==
		4271	R.PenaltyBreakBeforeFirstCallParameter &&
		4272	PenaltyBreakComment == R.PenaltyBreakComment &&
		4273	PenaltyBreakFirstLessLess == R.PenaltyBreakFirstLessLess &&
		4274	PenaltyBreakOpenParenthesis == R.PenaltyBreakOpenParenthesis &&
		4275	PenaltyBreakString == R.PenaltyBreakString &&
		4276	PenaltyBreakTemplateDeclaration ==
		4277	R.PenaltyBreakTemplateDeclaration &&
		4278	PenaltyExcessCharacter == R.PenaltyExcessCharacter &&
		4279	PenaltyReturnTypeOnItsOwnLine == R.PenaltyReturnTypeOnItsOwnLine &&
		4280	PointerAlignment == R.PointerAlignment &&
		4281	QualifierAlignment == R.QualifierAlignment &&
		4282	QualifierOrder == R.QualifierOrder &&
		4283	RawStringFormats == R.RawStringFormats &&
		4284	ReferenceAlignment == R.ReferenceAlignment &&
		4285	RemoveBracesLLVM == R.RemoveBracesLLVM &&
		4286	RemoveSemicolon == R.RemoveSemicolon &&
		4287	RequiresClausePosition == R.RequiresClausePosition &&
		4288	RequiresExpressionIndentation == R.RequiresExpressionIndentation &&
		4289	SeparateDefinitionBlocks == R.SeparateDefinitionBlocks &&
		4290	ShortNamespaceLines == R.ShortNamespaceLines &&
		4291	SortIncludes == R.SortIncludes &&
		4292	SortJavaStaticImport == R.SortJavaStaticImport &&
		4293	SpaceAfterCStyleCast == R.SpaceAfterCStyleCast &&
		4294	SpaceAfterLogicalNot == R.SpaceAfterLogicalNot &&
		4295	SpaceAfterTemplateKeyword == R.SpaceAfterTemplateKeyword &&
		4296	SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators &&
		4297	SpaceBeforeCaseColon == R.SpaceBeforeCaseColon &&
		4298	SpaceBeforeCpp11BracedList == R.SpaceBeforeCpp11BracedList &&
		4299	SpaceBeforeCtorInitializerColon ==
		4300	R.SpaceBeforeCtorInitializerColon &&
		4301	SpaceBeforeInheritanceColon == R.SpaceBeforeInheritanceColon &&
		4302	SpaceBeforeParens == R.SpaceBeforeParens &&
		4303	SpaceBeforeParensOptions == R.SpaceBeforeParensOptions &&
		4304	SpaceAroundPointerQualifiers == R.SpaceAroundPointerQualifiers &&
		4305	SpaceBeforeRangeBasedForLoopColon ==
		4306	R.SpaceBeforeRangeBasedForLoopColon &&
		4307	SpaceBeforeSquareBrackets == R.SpaceBeforeSquareBrackets &&
		4308	SpaceInEmptyBlock == R.SpaceInEmptyBlock &&
		4309	SpaceInEmptyParentheses == R.SpaceInEmptyParentheses &&
		4310	SpacesBeforeTrailingComments == R.SpacesBeforeTrailingComments &&
		4311	SpacesInAngles == R.SpacesInAngles &&
		4312	SpacesInConditionalStatement == R.SpacesInConditionalStatement &&
		4313	SpacesInContainerLiterals == R.SpacesInContainerLiterals &&
		4314	SpacesInCStyleCastParentheses == R.SpacesInCStyleCastParentheses &&
		4315	SpacesInLineCommentPrefix.Minimum ==
		4316	R.SpacesInLineCommentPrefix.Minimum &&
		4317	SpacesInLineCommentPrefix.Maximum ==
		4318	R.SpacesInLineCommentPrefix.Maximum &&
		4319	SpacesInParentheses == R.SpacesInParentheses &&
		4320	SpacesInSquareBrackets == R.SpacesInSquareBrackets &&
		4321	Standard == R.Standard &&
		4322	StatementAttributeLikeMacros == R.StatementAttributeLikeMacros &&
		4323	StatementMacros == R.StatementMacros && TabWidth == R.TabWidth &&
		4324	TypenameMacros == R.TypenameMacros && UseTab == R.UseTab &&
		4325	WhitespaceSensitiveMacros == R.WhitespaceSensitiveMacros;
		4326	}
		4327
		4328	std::optional<FormatStyle> GetLanguageStyle(LanguageKind Language) const;
		4329
		4330	// Stores per-language styles. A FormatStyle instance inside has an empty
		4331	// StyleSet. A FormatStyle instance returned by the Get method has its
		4332	// StyleSet set to a copy of the originating StyleSet, effectively keeping the
		4333	// internal representation of that StyleSet alive.
		4334	//
		4335	// The memory management and ownership reminds of a birds nest: chicks
		4336	// leaving the nest take photos of the nest with them.
		4337	struct FormatStyleSet {
		4338	typedef std::map<FormatStyle::LanguageKind, FormatStyle> MapType;
		4339
		4340	std::optional<FormatStyle> Get(FormatStyle::LanguageKind Language) const;
		4341
		4342	// Adds \p Style to this FormatStyleSet. Style must not have an associated
		4343	// FormatStyleSet.
		4344	// Style.Language should be different than LK_None. If this FormatStyleSet
		4345	// already contains an entry for Style.Language, that gets replaced with the
		4346	// passed Style.
		4347	void Add(FormatStyle Style);
		4348
		4349	// Clears this FormatStyleSet.
		4350	void Clear();
		4351
		4352	private:
		4353	std::shared_ptr<MapType> Styles;
		4354	};
		4355
		4356	static FormatStyleSet BuildStyleSetFromConfiguration(
		4357	const FormatStyle &MainStyle,
		4358	const std::vector<FormatStyle> &ConfigurationStyles);
		4359
		4360	private:
		4361	FormatStyleSet StyleSet;
		4362
		4363	friend std::error_code
		4364	parseConfiguration(llvm::MemoryBufferRef Config, FormatStyle *Style,
		4365	bool AllowUnknownOptions,
		4366	llvm::SourceMgr::DiagHandlerTy DiagHandler,
		4367	void *DiagHandlerCtxt);
		4368	};
		4369
		4370	/// Returns a format style complying with the LLVM coding standards:
		4371	/// http://llvm.org/docs/CodingStandards.html.
		4372	FormatStyle getLLVMStyle(
		4373	FormatStyle::LanguageKind Language = FormatStyle::LanguageKind::LK_Cpp);
		4374
		4375	/// Returns a format style complying with one of Google's style guides:
		4376	/// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml.
		4377	/// http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml.
		4378	/// https://developers.google.com/protocol-buffers/docs/style.
		4379	FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language);
		4380
		4381	/// Returns a format style complying with Chromium's style guide:
		4382	/// http://www.chromium.org/developers/coding-style.
		4383	FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language);
		4384
		4385	/// Returns a format style complying with Mozilla's style guide:
		4386	/// https://firefox-source-docs.mozilla.org/code-quality/coding-style/index.html.
		4387	FormatStyle getMozillaStyle();
		4388
		4389	/// Returns a format style complying with Webkit's style guide:
		4390	/// http://www.webkit.org/coding/coding-style.html
		4391	FormatStyle getWebKitStyle();
		4392
		4393	/// Returns a format style complying with GNU Coding Standards:
		4394	/// http://www.gnu.org/prep/standards/standards.html
		4395	FormatStyle getGNUStyle();
		4396
		4397	/// Returns a format style complying with Microsoft style guide:
		4398	/// https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference?view=vs-2017
		4399	FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language);
		4400
		4401	/// Returns style indicating formatting should be not applied at all.
		4402	FormatStyle getNoStyle();
		4403
		4404	/// Gets a predefined style for the specified language by name.
		4405	///
		4406	/// Currently supported names: LLVM, Google, Chromium, Mozilla. Names are
		4407	/// compared case-insensitively.
		4408	///
		4409	/// Returns ``true`` if the Style has been set.
		4410	bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
		4411	FormatStyle *Style);
		4412
		4413	/// Parse configuration from YAML-formatted text.
		4414	///
		4415	/// Style->Language is used to get the base style, if the ``BasedOnStyle``
		4416	/// option is present.
		4417	///
		4418	/// The FormatStyleSet of Style is reset.
		4419	///
		4420	/// When ``BasedOnStyle`` is not present, options not present in the YAML
		4421	/// document, are retained in \p Style.
		4422	///
		4423	/// If AllowUnknownOptions is true, no errors are emitted if unknown
		4424	/// format options are occurred.
		4425	///
		4426	/// If set all diagnostics are emitted through the DiagHandler.
		4427	std::error_code
		4428	parseConfiguration(llvm::MemoryBufferRef Config, FormatStyle *Style,
		4429	bool AllowUnknownOptions = false,
		4430	llvm::SourceMgr::DiagHandlerTy DiagHandler = nullptr,
		4431	void *DiagHandlerCtx = nullptr);
		4432
		4433	/// Like above but accepts an unnamed buffer.
		4434	inline std::error_code parseConfiguration(StringRef Config, FormatStyle *Style,
		4435	bool AllowUnknownOptions = false) {
		4436	return parseConfiguration(llvm::MemoryBufferRef(Config, "YAML"), Style,
		4437	AllowUnknownOptions);
		4438	}
		4439
		4440	/// Gets configuration in a YAML string.
		4441	std::string configurationAsText(const FormatStyle &Style);
		4442
		4443	/// Returns the replacements necessary to sort all ``#include`` blocks
		4444	/// that are affected by ``Ranges``.
		4445	tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
		4446	ArrayRef<tooling::Range> Ranges,
		4447	StringRef FileName,
		4448	unsigned *Cursor = nullptr);
		4449
		4450	/// Returns the replacements corresponding to applying and formatting
		4451	/// \p Replaces on success; otheriwse, return an llvm::Error carrying
		4452	/// llvm::StringError.
		4453	llvm::Expected<tooling::Replacements>
		4454	formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
		4455	const FormatStyle &Style);
		4456
		4457	/// Returns the replacements corresponding to applying \p Replaces and
		4458	/// cleaning up the code after that on success; otherwise, return an llvm::Error
		4459	/// carrying llvm::StringError.
		4460	/// This also supports inserting/deleting C++ #include directives:
		4461	/// - If a replacement has offset UINT_MAX, length 0, and a replacement text
		4462	/// that is an #include directive, this will insert the #include into the
		4463	/// correct block in the \p Code.
		4464	/// - If a replacement has offset UINT_MAX, length 1, and a replacement text
		4465	/// that is the name of the header to be removed, the header will be removed
		4466	/// from \p Code if it exists.
		4467	/// The include manipulation is done via `tooling::HeaderInclude`, see its
		4468	/// documentation for more details on how include insertion points are found and
		4469	/// what edits are produced.
		4470	llvm::Expected<tooling::Replacements>
		4471	cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
		4472	const FormatStyle &Style);
		4473
		4474	/// Represents the status of a formatting attempt.
		4475	struct FormattingAttemptStatus {
		4476	/// A value of ``false`` means that any of the affected ranges were not
		4477	/// formatted due to a non-recoverable syntax error.
		4478	bool FormatComplete = true;
		4479
		4480	/// If ``FormatComplete`` is false, ``Line`` records a one-based
		4481	/// original line number at which a syntax error might have occurred. This is
		4482	/// based on a best-effort analysis and could be imprecise.
		4483	unsigned Line = 0;
		4484	};
		4485
		4486	/// Reformats the given \p Ranges in \p Code.
		4487	///
		4488	/// Each range is extended on either end to its next bigger logic unit, i.e.
		4489	/// everything that might influence its formatting or might be influenced by its
		4490	/// formatting.
		4491	///
		4492	/// Returns the ``Replacements`` necessary to make all \p Ranges comply with
		4493	/// \p Style.
		4494	///
		4495	/// If ``Status`` is non-null, its value will be populated with the status of
		4496	/// this formatting attempt. See \c FormattingAttemptStatus.
		4497	tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
		4498	ArrayRef<tooling::Range> Ranges,
		4499	StringRef FileName = "<stdin>",
		4500	FormattingAttemptStatus *Status = nullptr);
		4501
		4502	/// Same as above, except if ``IncompleteFormat`` is non-null, its value
		4503	/// will be set to true if any of the affected ranges were not formatted due to
		4504	/// a non-recoverable syntax error.
		4505	tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
		4506	ArrayRef<tooling::Range> Ranges,
		4507	StringRef FileName, bool *IncompleteFormat);
		4508
		4509	/// Clean up any erroneous/redundant code in the given \p Ranges in \p
		4510	/// Code.
		4511	///
		4512	/// Returns the ``Replacements`` that clean up all \p Ranges in \p Code.
		4513	tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
		4514	ArrayRef<tooling::Range> Ranges,
		4515	StringRef FileName = "<stdin>");
		4516
		4517	/// Fix namespace end comments in the given \p Ranges in \p Code.
		4518	///
		4519	/// Returns the ``Replacements`` that fix the namespace comments in all
		4520	/// \p Ranges in \p Code.
		4521	tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
		4522	StringRef Code,
		4523	ArrayRef<tooling::Range> Ranges,
		4524	StringRef FileName = "<stdin>");
		4525
		4526	/// Inserts or removes empty lines separating definition blocks including
		4527	/// classes, structs, functions, namespaces, and enums in the given \p Ranges in
		4528	/// \p Code.
		4529	///
		4530	/// Returns the ``Replacements`` that inserts or removes empty lines separating
		4531	/// definition blocks in all \p Ranges in \p Code.
		4532	tooling::Replacements separateDefinitionBlocks(const FormatStyle &Style,
		4533	StringRef Code,
		4534	ArrayRef<tooling::Range> Ranges,
		4535	StringRef FileName = "<stdin>");
		4536
		4537	/// Sort consecutive using declarations in the given \p Ranges in
		4538	/// \p Code.
		4539	///
		4540	/// Returns the ``Replacements`` that sort the using declarations in all
		4541	/// \p Ranges in \p Code.
		4542	tooling::Replacements sortUsingDeclarations(const FormatStyle &Style,
		4543	StringRef Code,
		4544	ArrayRef<tooling::Range> Ranges,
		4545	StringRef FileName = "<stdin>");
		4546
		4547	/// Returns the ``LangOpts`` that the formatter expects you to set.
		4548	///
		4549	/// \param Style determines specific settings for lexing mode.
		4550	LangOptions getFormattingLangOpts(const FormatStyle &Style = getLLVMStyle());
		4551
		4552	/// Description to be used for help text for a ``llvm::cl`` option for
		4553	/// specifying format style. The description is closely related to the operation
		4554	/// of ``getStyle()``.
		4555	extern const char *StyleOptionHelpDescription;
		4556
		4557	/// The suggested format style to use by default. This allows tools using
		4558	/// `getStyle` to have a consistent default style.
		4559	/// Different builds can modify the value to the preferred styles.
		4560	extern const char *DefaultFormatStyle;
		4561
		4562	/// The suggested predefined style to use as the fallback style in `getStyle`.
		4563	/// Different builds can modify the value to the preferred styles.
		4564	extern const char *DefaultFallbackStyle;
		4565
		4566	/// Construct a FormatStyle based on ``StyleName``.
		4567	///
		4568	/// ``StyleName`` can take several forms:
		4569	/// * "{<key>: <value>, ...}" - Set specic style parameters.
		4570	/// * "<style name>" - One of the style names supported by
		4571	/// getPredefinedStyle().
		4572	/// * "file" - Load style configuration from a file called ``.clang-format``
		4573	/// located in one of the parent directories of ``FileName`` or the current
		4574	/// directory if ``FileName`` is empty.
		4575	/// * "file:<format_file_path>" to explicitly specify the configuration file to
		4576	/// use.
		4577	///
		4578	/// \param[in] StyleName Style name to interpret according to the description
		4579	/// above.
		4580	/// \param[in] FileName Path to start search for .clang-format if ``StyleName``
		4581	/// == "file".
		4582	/// \param[in] FallbackStyle The name of a predefined style used to fallback to
		4583	/// in case \p StyleName is "file" and no file can be found.
		4584	/// \param[in] Code The actual code to be formatted. Used to determine the
		4585	/// language if the filename isn't sufficient.
		4586	/// \param[in] FS The underlying file system, in which the file resides. By
		4587	/// default, the file system is the real file system.
		4588	/// \param[in] AllowUnknownOptions If true, unknown format options only
		4589	/// emit a warning. If false, errors are emitted on unknown format
		4590	/// options.
		4591	///
		4592	/// \returns FormatStyle as specified by ``StyleName``. If ``StyleName`` is
		4593	/// "file" and no file is found, returns ``FallbackStyle``. If no style could be
		4594	/// determined, returns an Error.
		4595	llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
		4596	StringRef FallbackStyle,
		4597	StringRef Code = "",
		4598	llvm::vfs::FileSystem *FS = nullptr,
		4599	bool AllowUnknownOptions = false);
		4600
		4601	// Guesses the language from the ``FileName`` and ``Code`` to be formatted.
		4602	// Defaults to FormatStyle::LK_Cpp.
		4603	FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code);
		4604
		4605	// Returns a string representation of ``Language``.
		4606	inline StringRef getLanguageName(FormatStyle::LanguageKind Language) {
		4607	switch (Language) {
		4608	case FormatStyle::LK_Cpp:
		4609	return "C++";
		4610	case FormatStyle::LK_CSharp:
		4611	return "CSharp";
		4612	case FormatStyle::LK_ObjC:
		4613	return "Objective-C";
		4614	case FormatStyle::LK_Java:
		4615	return "Java";
		4616	case FormatStyle::LK_JavaScript:
		4617	return "JavaScript";
		4618	case FormatStyle::LK_Json:
		4619	return "Json";
		4620	case FormatStyle::LK_Proto:
		4621	return "Proto";
		4622	case FormatStyle::LK_TableGen:
		4623	return "TableGen";
		4624	case FormatStyle::LK_TextProto:
		4625	return "TextProto";
		4626	case FormatStyle::LK_Verilog:
		4627	return "Verilog";
		4628	default:
		4629	return "Unknown";
		4630	}
		4631	}
		4632
		4633	} // end namespace format
		4634	} // end namespace clang
		4635
		4636	namespace std {
		4637	template <>
		4638	struct is_error_code_enum<clang::format::ParseError> : std::true_type {};
		4639	} // namespace std
		4640
		4641	#endif // LLVM_CLANG_FORMAT_FORMAT_H

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

QNX 8.QNX8 LLVM/Clang compiler suite/llvm-build/x86_64/include/clang/Format/Format.h – Rev 14