Warning: This file is not a C or C++ file. It does not have highlighting.

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

Warning: This file is not a C or C++ file. It does not have highlighting.