clang  10.0.0git
Format.h
Go to the documentation of this file.
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 
20 #include "llvm/ADT/ArrayRef.h"
21 #include "llvm/Support/Regex.h"
22 #include <system_error>
23 
24 namespace llvm {
25 namespace vfs {
26 class FileSystem;
27 }
28 } // namespace llvm
29 
30 namespace clang {
31 
32 class Lexer;
33 class SourceManager;
34 class DiagnosticConsumer;
35 
36 namespace format {
37 
38 enum class ParseError { Success = 0, Error, Unsuitable };
39 class ParseErrorCategory final : public std::error_category {
40 public:
41  const char *name() const noexcept override;
42  std::string message(int EV) const override;
43 };
44 const std::error_category &getParseCategory();
45 std::error_code make_error_code(ParseError e);
46 
47 /// The ``FormatStyle`` is used to configure the formatting to follow
48 /// specific guidelines.
49 struct FormatStyle {
50  /// The extra indent or outdent of access modifiers, e.g. ``public:``.
52 
53  /// Different styles for aligning after open brackets.
55  /// Align parameters on the open bracket, e.g.:
56  /// \code
57  /// someLongFunction(argument1,
58  /// argument2);
59  /// \endcode
61  /// Don't align, instead use ``ContinuationIndentWidth``, e.g.:
62  /// \code
63  /// someLongFunction(argument1,
64  /// argument2);
65  /// \endcode
67  /// Always break after an open bracket, if the parameters don't fit
68  /// on a single line, e.g.:
69  /// \code
70  /// someLongFunction(
71  /// argument1, argument2);
72  /// \endcode
74  };
75 
76  /// If ``true``, horizontally aligns arguments after an open bracket.
77  ///
78  /// This applies to round brackets (parentheses), angle brackets and square
79  /// brackets.
81 
82  /// \brief If ``true``, aligns consecutive C/C++ preprocessor macros.
83  ///
84  /// This will align C/C++ preprocessor macros of consecutive lines.
85  /// Will result in formattings like
86  /// \code
87  /// #define SHORT_NAME 42
88  /// #define LONGER_NAME 0x007f
89  /// #define EVEN_LONGER_NAME (2)
90  /// #define foo(x) (x * x)
91  /// #define bar(y, z) (y + z)
92  /// \endcode
94 
95  /// If ``true``, aligns consecutive assignments.
96  ///
97  /// This will align the assignment operators of consecutive lines. This
98  /// will result in formattings like
99  /// \code
100  /// int aaaa = 12;
101  /// int b = 23;
102  /// int ccc = 23;
103  /// \endcode
105 
106  /// If ``true``, aligns consecutive declarations.
107  ///
108  /// This will align the declaration names of consecutive lines. This
109  /// will result in formattings like
110  /// \code
111  /// int aaaa = 12;
112  /// float b = 23;
113  /// std::string ccc = 23;
114  /// \endcode
116 
117  /// Different styles for aligning escaped newlines.
119  /// Don't align escaped newlines.
120  /// \code
121  /// #define A \
122  /// int aaaa; \
123  /// int b; \
124  /// int dddddddddd;
125  /// \endcode
127  /// Align escaped newlines as far left as possible.
128  /// \code
129  /// true:
130  /// #define A \
131  /// int aaaa; \
132  /// int b; \
133  /// int dddddddddd;
134  ///
135  /// false:
136  /// \endcode
138  /// Align escaped newlines in the right-most column.
139  /// \code
140  /// #define A \
141  /// int aaaa; \
142  /// int b; \
143  /// int dddddddddd;
144  /// \endcode
146  };
147 
148  /// Options for aligning backslashes in escaped newlines.
150 
151  /// If ``true``, horizontally align operands of binary and ternary
152  /// expressions.
153  ///
154  /// Specifically, this aligns operands of a single expression that needs to be
155  /// split over multiple lines, e.g.:
156  /// \code
157  /// int aaa = bbbbbbbbbbbbbbb +
158  /// ccccccccccccccc;
159  /// \endcode
161 
162  /// If ``true``, aligns trailing comments.
163  /// \code
164  /// true: false:
165  /// int a; // My comment a vs. int a; // My comment a
166  /// int b = 2; // comment b int b = 2; // comment about b
167  /// \endcode
169 
170  /// \brief If a function call or braced initializer list doesn't fit on a
171  /// line, allow putting all arguments onto the next line, even if
172  /// ``BinPackArguments`` is ``false``.
173  /// \code
174  /// true:
175  /// callFunction(
176  /// a, b, c, d);
177  ///
178  /// false:
179  /// callFunction(a,
180  /// b,
181  /// c,
182  /// d);
183  /// \endcode
185 
186  /// \brief If a constructor definition with a member initializer list doesn't
187  /// fit on a single line, allow putting all member initializers onto the next
188  /// line, if ```ConstructorInitializerAllOnOneLineOrOnePerLine``` is true.
189  /// Note that this parameter has no effect if
190  /// ```ConstructorInitializerAllOnOneLineOrOnePerLine``` is false.
191  /// \code
192  /// true:
193  /// MyClass::MyClass() :
194  /// member0(0), member1(2) {}
195  ///
196  /// false:
197  /// MyClass::MyClass() :
198  /// member0(0),
199  /// member1(2) {}
200  bool AllowAllConstructorInitializersOnNextLine;
201 
202  /// If the function declaration doesn't fit on a line,
203  /// allow putting all parameters of a function declaration onto
204  /// the next line even if ``BinPackParameters`` is ``false``.
205  /// \code
206  /// true:
207  /// void myFunction(
208  /// int a, int b, int c, int d, int e);
209  ///
210  /// false:
211  /// void myFunction(int a,
212  /// int b,
213  /// int c,
214  /// int d,
215  /// int e);
216  /// \endcode
217  bool AllowAllParametersOfDeclarationOnNextLine;
218 
219  /// Different styles for merging short blocks containing at most one
220  /// statement.
221  enum ShortBlockStyle {
222  /// Never merge blocks into a single line.
223  /// \code
224  /// while (true) {
225  /// }
226  /// while (true) {
227  /// continue;
228  /// }
229  /// \endcode
230  SBS_Never,
231  /// Only merge empty blocks.
232  /// \code
233  /// while (true) {}
234  /// while (true) {
235  /// continue;
236  /// }
237  /// \endcode
238  SBS_Empty,
239  /// Always merge short blocks into a single line.
240  /// \code
241  /// while (true) {}
242  /// while (true) { continue; }
243  /// \endcode
244  SBS_Always,
245  };
246 
247  /// Dependent on the value, ``while (true) { continue; }`` can be put on a
248  /// single line.
249  ShortBlockStyle AllowShortBlocksOnASingleLine;
250 
251  /// If ``true``, short case labels will be contracted to a single line.
252  /// \code
253  /// true: false:
254  /// switch (a) { vs. switch (a) {
255  /// case 1: x = 1; break; case 1:
256  /// case 2: return; x = 1;
257  /// } break;
258  /// case 2:
259  /// return;
260  /// }
261  /// \endcode
262  bool AllowShortCaseLabelsOnASingleLine;
263 
264  /// Different styles for merging short functions containing at most one
265  /// statement.
266  enum ShortFunctionStyle {
267  /// Never merge functions into a single line.
268  SFS_None,
269  /// Only merge functions defined inside a class. Same as "inline",
270  /// except it does not implies "empty": i.e. top level empty functions
271  /// are not merged either.
272  /// \code
273  /// class Foo {
274  /// void f() { foo(); }
275  /// };
276  /// void f() {
277  /// foo();
278  /// }
279  /// void f() {
280  /// }
281  /// \endcode
282  SFS_InlineOnly,
283  /// Only merge empty functions.
284  /// \code
285  /// void f() {}
286  /// void f2() {
287  /// bar2();
288  /// }
289  /// \endcode
290  SFS_Empty,
291  /// Only merge functions defined inside a class. Implies "empty".
292  /// \code
293  /// class Foo {
294  /// void f() { foo(); }
295  /// };
296  /// void f() {
297  /// foo();
298  /// }
299  /// void f() {}
300  /// \endcode
301  SFS_Inline,
302  /// Merge all functions fitting on a single line.
303  /// \code
304  /// class Foo {
305  /// void f() { foo(); }
306  /// };
307  /// void f() { bar(); }
308  /// \endcode
309  SFS_All,
310  };
311 
312  /// Dependent on the value, ``int f() { return 0; }`` can be put on a
313  /// single line.
314  ShortFunctionStyle AllowShortFunctionsOnASingleLine;
315 
316  /// Different styles for handling short if lines
317  enum ShortIfStyle {
318  /// Never put short ifs on the same line.
319  /// \code
320  /// if (a)
321  /// return ;
322  /// else {
323  /// return;
324  /// }
325  /// \endcode
326  SIS_Never,
327  /// Without else put short ifs on the same line only if
328  /// the else is not a compound statement.
329  /// \code
330  /// if (a) return;
331  /// else
332  /// return;
333  /// \endcode
334  SIS_WithoutElse,
335  /// Always put short ifs on the same line if
336  /// the else is not a compound statement or not.
337  /// \code
338  /// if (a) return;
339  /// else {
340  /// return;
341  /// }
342  /// \endcode
343  SIS_Always,
344  };
345 
346  /// If ``true``, ``if (a) return;`` can be put on a single line.
347  ShortIfStyle AllowShortIfStatementsOnASingleLine;
348 
349  /// Different styles for merging short lambdas containing at most one
350  /// statement.
351  enum ShortLambdaStyle {
352  /// Never merge lambdas into a single line.
353  SLS_None,
354  /// Only merge empty lambdas.
355  /// \code
356  /// auto lambda = [](int a) {}
357  /// auto lambda2 = [](int a) {
358  /// return a;
359  /// };
360  /// \endcode
361  SLS_Empty,
362  /// Merge lambda into a single line if argument of a function.
363  /// \code
364  /// auto lambda = [](int a) {
365  /// return a;
366  /// };
367  /// sort(a.begin(), a.end(), ()[] { return x < y; })
368  /// \endcode
369  SLS_Inline,
370  /// Merge all lambdas fitting on a single line.
371  /// \code
372  /// auto lambda = [](int a) {}
373  /// auto lambda2 = [](int a) { return a; };
374  /// \endcode
375  SLS_All,
376  };
377 
378  /// Dependent on the value, ``auto lambda []() { return 0; }`` can be put on a
379  /// single line.
380  ShortLambdaStyle AllowShortLambdasOnASingleLine;
381 
382  /// If ``true``, ``while (true) continue;`` can be put on a single
383  /// line.
384  bool AllowShortLoopsOnASingleLine;
385 
386  /// Different ways to break after the function definition return type.
387  /// This option is **deprecated** and is retained for backwards compatibility.
388  enum DefinitionReturnTypeBreakingStyle {
389  /// Break after return type automatically.
390  /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
391  DRTBS_None,
392  /// Always break after the return type.
393  DRTBS_All,
394  /// Always break after the return types of top-level functions.
395  DRTBS_TopLevel,
396  };
397 
398  /// Different ways to break after the function definition or
399  /// declaration return type.
400  enum ReturnTypeBreakingStyle {
401  /// Break after return type automatically.
402  /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
403  /// \code
404  /// class A {
405  /// int f() { return 0; };
406  /// };
407  /// int f();
408  /// int f() { return 1; }
409  /// \endcode
410  RTBS_None,
411  /// Always break after the return type.
412  /// \code
413  /// class A {
414  /// int
415  /// f() {
416  /// return 0;
417  /// };
418  /// };
419  /// int
420  /// f();
421  /// int
422  /// f() {
423  /// return 1;
424  /// }
425  /// \endcode
426  RTBS_All,
427  /// Always break after the return types of top-level functions.
428  /// \code
429  /// class A {
430  /// int f() { return 0; };
431  /// };
432  /// int
433  /// f();
434  /// int
435  /// f() {
436  /// return 1;
437  /// }
438  /// \endcode
439  RTBS_TopLevel,
440  /// Always break after the return type of function definitions.
441  /// \code
442  /// class A {
443  /// int
444  /// f() {
445  /// return 0;
446  /// };
447  /// };
448  /// int f();
449  /// int
450  /// f() {
451  /// return 1;
452  /// }
453  /// \endcode
454  RTBS_AllDefinitions,
455  /// Always break after the return type of top-level definitions.
456  /// \code
457  /// class A {
458  /// int f() { return 0; };
459  /// };
460  /// int f();
461  /// int
462  /// f() {
463  /// return 1;
464  /// }
465  /// \endcode
466  RTBS_TopLevelDefinitions,
467  };
468 
469  /// The function definition return type breaking style to use. This
470  /// option is **deprecated** and is retained for backwards compatibility.
471  DefinitionReturnTypeBreakingStyle AlwaysBreakAfterDefinitionReturnType;
472 
473  /// The function declaration return type breaking style to use.
474  ReturnTypeBreakingStyle AlwaysBreakAfterReturnType;
475 
476  /// If ``true``, always break before multiline string literals.
477  ///
478  /// This flag is mean to make cases where there are multiple multiline strings
479  /// in a file look more consistent. Thus, it will only take effect if wrapping
480  /// the string at that point leads to it being indented
481  /// ``ContinuationIndentWidth`` spaces from the start of the line.
482  /// \code
483  /// true: false:
484  /// aaaa = vs. aaaa = "bbbb"
485  /// "bbbb" "cccc";
486  /// "cccc";
487  /// \endcode
488  bool AlwaysBreakBeforeMultilineStrings;
489 
490  /// Different ways to break after the template declaration.
491  enum BreakTemplateDeclarationsStyle {
492  /// Do not force break before declaration.
493  /// ``PenaltyBreakTemplateDeclaration`` is taken into account.
494  /// \code
495  /// template <typename T> T foo() {
496  /// }
497  /// template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa,
498  /// int bbbbbbbbbbbbbbbbbbbbb) {
499  /// }
500  /// \endcode
501  BTDS_No,
502  /// Force break after template declaration only when the following
503  /// declaration spans multiple lines.
504  /// \code
505  /// template <typename T> T foo() {
506  /// }
507  /// template <typename T>
508  /// T foo(int aaaaaaaaaaaaaaaaaaaaa,
509  /// int bbbbbbbbbbbbbbbbbbbbb) {
510  /// }
511  /// \endcode
512  BTDS_MultiLine,
513  /// Always break after template declaration.
514  /// \code
515  /// template <typename T>
516  /// T foo() {
517  /// }
518  /// template <typename T>
519  /// T foo(int aaaaaaaaaaaaaaaaaaaaa,
520  /// int bbbbbbbbbbbbbbbbbbbbb) {
521  /// }
522  /// \endcode
523  BTDS_Yes
524  };
525 
526  /// The template declaration breaking style to use.
527  BreakTemplateDeclarationsStyle AlwaysBreakTemplateDeclarations;
528 
529  /// If ``false``, a function call's arguments will either be all on the
530  /// same line or will have one line each.
531  /// \code
532  /// true:
533  /// void f() {
534  /// f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
535  /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
536  /// }
537  ///
538  /// false:
539  /// void f() {
540  /// f(aaaaaaaaaaaaaaaaaaaa,
541  /// aaaaaaaaaaaaaaaaaaaa,
542  /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
543  /// }
544  /// \endcode
545  bool BinPackArguments;
546 
547  /// If ``false``, a function declaration's or function definition's
548  /// parameters will either all be on the same line or will have one line each.
549  /// \code
550  /// true:
551  /// void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
552  /// int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
553  ///
554  /// false:
555  /// void f(int aaaaaaaaaaaaaaaaaaaa,
556  /// int aaaaaaaaaaaaaaaaaaaa,
557  /// int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
558  /// \endcode
559  bool BinPackParameters;
560 
561  /// The style of wrapping parameters on the same line (bin-packed) or
562  /// on one line each.
563  enum BinPackStyle {
564  /// Automatically determine parameter bin-packing behavior.
565  BPS_Auto,
566  /// Always bin-pack parameters.
567  BPS_Always,
568  /// Never bin-pack parameters.
569  BPS_Never,
570  };
571 
572  /// The style of breaking before or after binary operators.
573  enum BinaryOperatorStyle {
574  /// Break after operators.
575  /// \code
576  /// LooooooooooongType loooooooooooooooooooooongVariable =
577  /// someLooooooooooooooooongFunction();
578  ///
579  /// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +
580  /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==
581  /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
582  /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >
583  /// ccccccccccccccccccccccccccccccccccccccccc;
584  /// \endcode
585  BOS_None,
586  /// Break before operators that aren't assignments.
587  /// \code
588  /// LooooooooooongType loooooooooooooooooooooongVariable =
589  /// someLooooooooooooooooongFunction();
590  ///
591  /// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
592  /// + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
593  /// == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
594  /// && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
595  /// > ccccccccccccccccccccccccccccccccccccccccc;
596  /// \endcode
597  BOS_NonAssignment,
598  /// Break before operators.
599  /// \code
600  /// LooooooooooongType loooooooooooooooooooooongVariable
601  /// = someLooooooooooooooooongFunction();
602  ///
603  /// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
604  /// + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
605  /// == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
606  /// && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
607  /// > ccccccccccccccccccccccccccccccccccccccccc;
608  /// \endcode
609  BOS_All,
610  };
611 
612  /// The way to wrap binary operators.
613  BinaryOperatorStyle BreakBeforeBinaryOperators;
614 
615  /// Different ways to attach braces to their surrounding context.
616  enum BraceBreakingStyle {
617  /// Always attach braces to surrounding context.
618  /// \code
619  /// try {
620  /// foo();
621  /// } catch () {
622  /// }
623  /// void foo() { bar(); }
624  /// class foo {};
625  /// if (foo()) {
626  /// } else {
627  /// }
628  /// enum X : int { A, B };
629  /// \endcode
630  BS_Attach,
631  /// Like ``Attach``, but break before braces on function, namespace and
632  /// class definitions.
633  /// \code
634  /// try {
635  /// foo();
636  /// } catch () {
637  /// }
638  /// void foo() { bar(); }
639  /// class foo
640  /// {
641  /// };
642  /// if (foo()) {
643  /// } else {
644  /// }
645  /// enum X : int { A, B };
646  /// \endcode
647  BS_Linux,
648  /// Like ``Attach``, but break before braces on enum, function, and record
649  /// definitions.
650  /// \code
651  /// try {
652  /// foo();
653  /// } catch () {
654  /// }
655  /// void foo() { bar(); }
656  /// class foo
657  /// {
658  /// };
659  /// if (foo()) {
660  /// } else {
661  /// }
662  /// enum X : int { A, B };
663  /// \endcode
664  BS_Mozilla,
665  /// Like ``Attach``, but break before function definitions, ``catch``, and
666  /// ``else``.
667  /// \code
668  /// try {
669  /// foo();
670  /// }
671  /// catch () {
672  /// }
673  /// void foo() { bar(); }
674  /// class foo {
675  /// };
676  /// if (foo()) {
677  /// }
678  /// else {
679  /// }
680  /// enum X : int { A, B };
681  /// \endcode
682  BS_Stroustrup,
683  /// Always break before braces.
684  /// \code
685  /// try
686  /// {
687  /// foo();
688  /// }
689  /// catch ()
690  /// {
691  /// }
692  /// void foo() { bar(); }
693  /// class foo
694  /// {
695  /// };
696  /// if (foo())
697  /// {
698  /// }
699  /// else
700  /// {
701  /// }
702  /// enum X : int
703  /// {
704  /// A,
705  /// B
706  /// };
707  /// \endcode
708  BS_Allman,
709  /// Like ``Allman`` but always indent braces and line up code with braces.
710  /// \code
711  /// try
712  /// {
713  /// foo();
714  /// }
715  /// catch ()
716  /// {
717  /// }
718  /// void foo() { bar(); }
719  /// class foo
720  /// {
721  /// };
722  /// if (foo())
723  /// {
724  /// }
725  /// else
726  /// {
727  /// }
728  /// enum X : int
729  /// {
730  /// A,
731  /// B
732  /// };
733  /// \endcode
734  BS_Whitesmiths,
735  /// Always break before braces and add an extra level of indentation to
736  /// braces of control statements, not to those of class, function
737  /// or other definitions.
738  /// \code
739  /// try
740  /// {
741  /// foo();
742  /// }
743  /// catch ()
744  /// {
745  /// }
746  /// void foo() { bar(); }
747  /// class foo
748  /// {
749  /// };
750  /// if (foo())
751  /// {
752  /// }
753  /// else
754  /// {
755  /// }
756  /// enum X : int
757  /// {
758  /// A,
759  /// B
760  /// };
761  /// \endcode
762  BS_GNU,
763  /// Like ``Attach``, but break before functions.
764  /// \code
765  /// try {
766  /// foo();
767  /// } catch () {
768  /// }
769  /// void foo() { bar(); }
770  /// class foo {
771  /// };
772  /// if (foo()) {
773  /// } else {
774  /// }
775  /// enum X : int { A, B };
776  /// \endcode
777  BS_WebKit,
778  /// Configure each individual brace in `BraceWrapping`.
779  BS_Custom
780  };
781 
782  /// The brace breaking style to use.
783  BraceBreakingStyle BreakBeforeBraces;
784 
785  /// Different ways to wrap braces after control statements.
786  enum BraceWrappingAfterControlStatementStyle {
787  /// Never wrap braces after a control statement.
788  /// \code
789  /// if (foo()) {
790  /// } else {
791  /// }
792  /// for (int i = 0; i < 10; ++i) {
793  /// }
794  /// \endcode
795  BWACS_Never,
796  /// Only wrap braces after a multi-line control statement.
797  /// \code
798  /// if (foo && bar &&
799  /// baz)
800  /// {
801  /// quux();
802  /// }
803  /// while (foo || bar) {
804  /// }
805  /// \endcode
806  BWACS_MultiLine,
807  /// Always wrap braces after a control statement.
808  /// \code
809  /// if (foo())
810  /// {
811  /// } else
812  /// {}
813  /// for (int i = 0; i < 10; ++i)
814  /// {}
815  /// \endcode
816  BWACS_Always
817  };
818 
819  /// Precise control over the wrapping of braces.
820  /// \code
821  /// # Should be declared this way:
822  /// BreakBeforeBraces: Custom
823  /// BraceWrapping:
824  /// AfterClass: true
825  /// \endcode
826  struct BraceWrappingFlags {
827  /// Wrap case labels.
828  /// \code
829  /// false: true:
830  /// switch (foo) { vs. switch (foo) {
831  /// case 1: { case 1:
832  /// bar(); {
833  /// break; bar();
834  /// } break;
835  /// default: { }
836  /// plop(); default:
837  /// } {
838  /// } plop();
839  /// }
840  /// }
841  /// \endcode
842  bool AfterCaseLabel;
843  /// Wrap class definitions.
844  /// \code
845  /// true:
846  /// class foo {};
847  ///
848  /// false:
849  /// class foo
850  /// {};
851  /// \endcode
852  bool AfterClass;
853 
854  /// Wrap control statements (``if``/``for``/``while``/``switch``/..).
855  BraceWrappingAfterControlStatementStyle AfterControlStatement;
856  /// Wrap enum definitions.
857  /// \code
858  /// true:
859  /// enum X : int
860  /// {
861  /// B
862  /// };
863  ///
864  /// false:
865  /// enum X : int { B };
866  /// \endcode
867  bool AfterEnum;
868  /// Wrap function definitions.
869  /// \code
870  /// true:
871  /// void foo()
872  /// {
873  /// bar();
874  /// bar2();
875  /// }
876  ///
877  /// false:
878  /// void foo() {
879  /// bar();
880  /// bar2();
881  /// }
882  /// \endcode
883  bool AfterFunction;
884  /// Wrap namespace definitions.
885  /// \code
886  /// true:
887  /// namespace
888  /// {
889  /// int foo();
890  /// int bar();
891  /// }
892  ///
893  /// false:
894  /// namespace {
895  /// int foo();
896  /// int bar();
897  /// }
898  /// \endcode
899  bool AfterNamespace;
900  /// Wrap ObjC definitions (interfaces, implementations...).
901  /// \note @autoreleasepool and @synchronized blocks are wrapped
902  /// according to `AfterControlStatement` flag.
903  bool AfterObjCDeclaration;
904  /// Wrap struct definitions.
905  /// \code
906  /// true:
907  /// struct foo
908  /// {
909  /// int x;
910  /// };
911  ///
912  /// false:
913  /// struct foo {
914  /// int x;
915  /// };
916  /// \endcode
917  bool AfterStruct;
918  /// Wrap union definitions.
919  /// \code
920  /// true:
921  /// union foo
922  /// {
923  /// int x;
924  /// }
925  ///
926  /// false:
927  /// union foo {
928  /// int x;
929  /// }
930  /// \endcode
931  bool AfterUnion;
932  /// Wrap extern blocks.
933  /// \code
934  /// true:
935  /// extern "C"
936  /// {
937  /// int foo();
938  /// }
939  ///
940  /// false:
941  /// extern "C" {
942  /// int foo();
943  /// }
944  /// \endcode
945  bool AfterExternBlock;
946  /// Wrap before ``catch``.
947  /// \code
948  /// true:
949  /// try {
950  /// foo();
951  /// }
952  /// catch () {
953  /// }
954  ///
955  /// false:
956  /// try {
957  /// foo();
958  /// } catch () {
959  /// }
960  /// \endcode
961  bool BeforeCatch;
962  /// Wrap before ``else``.
963  /// \code
964  /// true:
965  /// if (foo()) {
966  /// }
967  /// else {
968  /// }
969  ///
970  /// false:
971  /// if (foo()) {
972  /// } else {
973  /// }
974  /// \endcode
975  bool BeforeElse;
976  /// Indent the wrapped braces themselves.
977  bool IndentBraces;
978  /// If ``false``, empty function body can be put on a single line.
979  /// This option is used only if the opening brace of the function has
980  /// already been wrapped, i.e. the `AfterFunction` brace wrapping mode is
981  /// set, and the function could/should not be put on a single line (as per
982  /// `AllowShortFunctionsOnASingleLine` and constructor formatting options).
983  /// \code
984  /// int f() vs. int f()
985  /// {} {
986  /// }
987  /// \endcode
988  ///
989  bool SplitEmptyFunction;
990  /// If ``false``, empty record (e.g. class, struct or union) body
991  /// can be put on a single line. This option is used only if the opening
992  /// brace of the record has already been wrapped, i.e. the `AfterClass`
993  /// (for classes) brace wrapping mode is set.
994  /// \code
995  /// class Foo vs. class Foo
996  /// {} {
997  /// }
998  /// \endcode
999  ///
1000  bool SplitEmptyRecord;
1001  /// If ``false``, empty namespace body can be put on a single line.
1002  /// This option is used only if the opening brace of the namespace has
1003  /// already been wrapped, i.e. the `AfterNamespace` brace wrapping mode is
1004  /// set.
1005  /// \code
1006  /// namespace Foo vs. namespace Foo
1007  /// {} {
1008  /// }
1009  /// \endcode
1010  ///
1011  bool SplitEmptyNamespace;
1012  };
1013 
1014  /// Control of individual brace wrapping cases.
1015  ///
1016  /// If ``BreakBeforeBraces`` is set to ``BS_Custom``, use this to specify how
1017  /// each individual brace case should be handled. Otherwise, this is ignored.
1018  /// \code{.yaml}
1019  /// # Example of usage:
1020  /// BreakBeforeBraces: Custom
1021  /// BraceWrapping:
1022  /// AfterEnum: true
1023  /// AfterStruct: false
1024  /// SplitEmptyFunction: false
1025  /// \endcode
1026  BraceWrappingFlags BraceWrapping;
1027 
1028  /// If ``true``, ternary operators will be placed after line breaks.
1029  /// \code
1030  /// true:
1031  /// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
1032  /// ? firstValue
1033  /// : SecondValueVeryVeryVeryVeryLong;
1034  ///
1035  /// false:
1036  /// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
1037  /// firstValue :
1038  /// SecondValueVeryVeryVeryVeryLong;
1039  /// \endcode
1040  bool BreakBeforeTernaryOperators;
1041 
1042  /// Different ways to break initializers.
1043  enum BreakConstructorInitializersStyle {
1044  /// Break constructor initializers before the colon and after the commas.
1045  /// \code
1046  /// Constructor()
1047  /// : initializer1(),
1048  /// initializer2()
1049  /// \endcode
1050  BCIS_BeforeColon,
1051  /// Break constructor initializers before the colon and commas, and align
1052  /// the commas with the colon.
1053  /// \code
1054  /// Constructor()
1055  /// : initializer1()
1056  /// , initializer2()
1057  /// \endcode
1058  BCIS_BeforeComma,
1059  /// Break constructor initializers after the colon and commas.
1060  /// \code
1061  /// Constructor() :
1062  /// initializer1(),
1063  /// initializer2()
1064  /// \endcode
1065  BCIS_AfterColon
1066  };
1067 
1068  /// The constructor initializers style to use.
1069  BreakConstructorInitializersStyle BreakConstructorInitializers;
1070 
1071  /// Break after each annotation on a field in Java files.
1072  /// \code{.java}
1073  /// true: false:
1074  /// @Partial vs. @Partial @Mock DataLoad loader;
1075  /// @Mock
1076  /// DataLoad loader;
1077  /// \endcode
1078  bool BreakAfterJavaFieldAnnotations;
1079 
1080  /// Allow breaking string literals when formatting.
1081  /// \code
1082  /// true:
1083  /// const char* x = "veryVeryVeryVeryVeryVe"
1084  /// "ryVeryVeryVeryVeryVery"
1085  /// "VeryLongString";
1086  ///
1087  /// false:
1088  /// const char* x =
1089  /// "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";
1090  /// \endcode
1091  bool BreakStringLiterals;
1092 
1093  /// The column limit.
1094  ///
1095  /// A column limit of ``0`` means that there is no column limit. In this case,
1096  /// clang-format will respect the input's line breaking decisions within
1097  /// statements unless they contradict other rules.
1098  unsigned ColumnLimit;
1099 
1100  /// A regular expression that describes comments with special meaning,
1101  /// which should not be split into lines or otherwise changed.
1102  /// \code
1103  /// // CommentPragmas: '^ FOOBAR pragma:'
1104  /// // Will leave the following line unaffected
1105  /// #include <vector> // FOOBAR pragma: keep
1106  /// \endcode
1107  std::string CommentPragmas;
1108 
1109  /// Different ways to break inheritance list.
1110  enum BreakInheritanceListStyle {
1111  /// Break inheritance list before the colon and after the commas.
1112  /// \code
1113  /// class Foo
1114  /// : Base1,
1115  /// Base2
1116  /// {};
1117  /// \endcode
1118  BILS_BeforeColon,
1119  /// Break inheritance list before the colon and commas, and align
1120  /// the commas with the colon.
1121  /// \code
1122  /// class Foo
1123  /// : Base1
1124  /// , Base2
1125  /// {};
1126  /// \endcode
1127  BILS_BeforeComma,
1128  /// Break inheritance list after the colon and commas.
1129  /// \code
1130  /// class Foo :
1131  /// Base1,
1132  /// Base2
1133  /// {};
1134  /// \endcode
1135  BILS_AfterColon
1136  };
1137 
1138  /// The inheritance list style to use.
1139  BreakInheritanceListStyle BreakInheritanceList;
1140 
1141  /// If ``true``, consecutive namespace declarations will be on the same
1142  /// line. If ``false``, each namespace is declared on a new line.
1143  /// \code
1144  /// true:
1145  /// namespace Foo { namespace Bar {
1146  /// }}
1147  ///
1148  /// false:
1149  /// namespace Foo {
1150  /// namespace Bar {
1151  /// }
1152  /// }
1153  /// \endcode
1154  ///
1155  /// If it does not fit on a single line, the overflowing namespaces get
1156  /// wrapped:
1157  /// \code
1158  /// namespace Foo { namespace Bar {
1159  /// namespace Extra {
1160  /// }}}
1161  /// \endcode
1162  bool CompactNamespaces;
1163 
1164  // clang-format off
1165  /// If the constructor initializers don't fit on a line, put each
1166  /// initializer on its own line.
1167  /// \code
1168  /// true:
1169  /// SomeClass::Constructor()
1170  /// : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
1171  /// return 0;
1172  /// }
1173  ///
1174  /// false:
1175  /// SomeClass::Constructor()
1176  /// : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa),
1177  /// aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
1178  /// return 0;
1179  /// }
1180  /// \endcode
1181  bool ConstructorInitializerAllOnOneLineOrOnePerLine;
1182  // clang-format on
1183 
1184  /// The number of characters to use for indentation of constructor
1185  /// initializer lists as well as inheritance lists.
1186  unsigned ConstructorInitializerIndentWidth;
1187 
1188  /// Indent width for line continuations.
1189  /// \code
1190  /// ContinuationIndentWidth: 2
1191  ///
1192  /// int i = // VeryVeryVeryVeryVeryLongComment
1193  /// longFunction( // Again a long comment
1194  /// arg);
1195  /// \endcode
1196  unsigned ContinuationIndentWidth;
1197 
1198  /// If ``true``, format braced lists as best suited for C++11 braced
1199  /// lists.
1200  ///
1201  /// Important differences:
1202  /// - No spaces inside the braced list.
1203  /// - No line break before the closing brace.
1204  /// - Indentation with the continuation indent, not with the block indent.
1205  ///
1206  /// Fundamentally, C++11 braced lists are formatted exactly like function
1207  /// calls would be formatted in their place. If the braced list follows a name
1208  /// (e.g. a type or variable name), clang-format formats as if the ``{}`` were
1209  /// the parentheses of a function call with that name. If there is no name,
1210  /// a zero-length name is assumed.
1211  /// \code
1212  /// true: false:
1213  /// vector<int> x{1, 2, 3, 4}; vs. vector<int> x{ 1, 2, 3, 4 };
1214  /// vector<T> x{{}, {}, {}, {}}; vector<T> x{ {}, {}, {}, {} };
1215  /// f(MyMap[{composite, key}]); f(MyMap[{ composite, key }]);
1216  /// new int[3]{1, 2, 3}; new int[3]{ 1, 2, 3 };
1217  /// \endcode
1218  bool Cpp11BracedListStyle;
1219 
1220  /// \brief Analyze the formatted file for the most used line ending (``\r\n``
1221  /// or ``\n``). ``UseCRLF`` is only used as a fallback if none can be derived.
1222  bool DeriveLineEnding;
1223 
1224  /// If ``true``, analyze the formatted file for the most common
1225  /// alignment of ``&`` and ``*``.
1226  /// Pointer and reference alignment styles are going to be updated according
1227  /// to the preferences found in the file.
1228  /// ``PointerAlignment`` is then used only as fallback.
1229  bool DerivePointerAlignment;
1230 
1231  /// Disables formatting completely.
1232  bool DisableFormat;
1233 
1234  /// If ``true``, clang-format detects whether function calls and
1235  /// definitions are formatted with one parameter per line.
1236  ///
1237  /// Each call can be bin-packed, one-per-line or inconclusive. If it is
1238  /// inconclusive, e.g. completely on one line, but a decision needs to be
1239  /// made, clang-format analyzes whether there are other bin-packed cases in
1240  /// the input file and act accordingly.
1241  ///
1242  /// NOTE: This is an experimental flag, that might go away or be renamed. Do
1243  /// not use this in config files, etc. Use at your own risk.
1244  bool ExperimentalAutoDetectBinPacking;
1245 
1246  /// If ``true``, clang-format adds missing namespace end comments and
1247  /// fixes invalid existing ones.
1248  /// \code
1249  /// true: false:
1250  /// namespace a { vs. namespace a {
1251  /// foo(); foo();
1252  /// } // namespace a }
1253  /// \endcode
1254  bool FixNamespaceComments;
1255 
1256  /// A vector of macros that should be interpreted as foreach loops
1257  /// instead of as function calls.
1258  ///
1259  /// These are expected to be macros of the form:
1260  /// \code
1261  /// FOREACH(<variable-declaration>, ...)
1262  /// <loop-body>
1263  /// \endcode
1264  ///
1265  /// In the .clang-format configuration file, this can be configured like:
1266  /// \code{.yaml}
1267  /// ForEachMacros: ['RANGES_FOR', 'FOREACH']
1268  /// \endcode
1269  ///
1270  /// For example: BOOST_FOREACH.
1271  std::vector<std::string> ForEachMacros;
1272 
1273  /// \brief A vector of macros that should be interpreted as type declarations
1274  /// instead of as function calls.
1275  ///
1276  /// These are expected to be macros of the form:
1277  /// \code
1278  /// STACK_OF(...)
1279  /// \endcode
1280  ///
1281  /// In the .clang-format configuration file, this can be configured like:
1282  /// \code{.yaml}
1283  /// TypenameMacros: ['STACK_OF', 'LIST']
1284  /// \endcode
1285  ///
1286  /// For example: OpenSSL STACK_OF, BSD LIST_ENTRY.
1287  std::vector<std::string> TypenameMacros;
1288 
1289  /// A vector of macros that should be interpreted as complete
1290  /// statements.
1291  ///
1292  /// Typical macros are expressions, and require a semi-colon to be
1293  /// added; sometimes this is not the case, and this allows to make
1294  /// clang-format aware of such cases.
1295  ///
1296  /// For example: Q_UNUSED
1297  std::vector<std::string> StatementMacros;
1298 
1299  /// A vector of macros which are used to open namespace blocks.
1300  ///
1301  /// These are expected to be macros of the form:
1302  /// \code
1303  /// NAMESPACE(<namespace-name>, ...) {
1304  /// <namespace-content>
1305  /// }
1306  /// \endcode
1307  ///
1308  /// For example: TESTSUITE
1309  std::vector<std::string> NamespaceMacros;
1310 
1311  tooling::IncludeStyle IncludeStyle;
1312 
1313  /// Indent case labels one level from the switch statement.
1314  ///
1315  /// When ``false``, use the same indentation level as for the switch
1316  /// statement. Switch statement body is always indented one level more than
1317  /// case labels.
1318  /// \code
1319  /// false: true:
1320  /// switch (fool) { vs. switch (fool) {
1321  /// case 1: case 1:
1322  /// bar(); bar();
1323  /// break; break;
1324  /// default: default:
1325  /// plop(); plop();
1326  /// } }
1327  /// \endcode
1328  bool IndentCaseLabels;
1329 
1330  /// Indent goto labels.
1331  ///
1332  /// When ``false``, goto labels are flushed left.
1333  /// \code
1334  /// true: false:
1335  /// int f() { vs. int f() {
1336  /// if (foo()) { if (foo()) {
1337  /// label1: label1:
1338  /// bar(); bar();
1339  /// } }
1340  /// label2: label2:
1341  /// return 1; return 1;
1342  /// } }
1343  /// \endcode
1344  bool IndentGotoLabels;
1345 
1346  /// Options for indenting preprocessor directives.
1347  enum PPDirectiveIndentStyle {
1348  /// Does not indent any directives.
1349  /// \code
1350  /// #if FOO
1351  /// #if BAR
1352  /// #include <foo>
1353  /// #endif
1354  /// #endif
1355  /// \endcode
1356  PPDIS_None,
1357  /// Indents directives after the hash.
1358  /// \code
1359  /// #if FOO
1360  /// # if BAR
1361  /// # include <foo>
1362  /// # endif
1363  /// #endif
1364  /// \endcode
1365  PPDIS_AfterHash,
1366  /// Indents directives before the hash.
1367  /// \code
1368  /// #if FOO
1369  /// #if BAR
1370  /// #include <foo>
1371  /// #endif
1372  /// #endif
1373  /// \endcode
1374  PPDIS_BeforeHash
1375  };
1376 
1377  /// The preprocessor directive indenting style to use.
1378  PPDirectiveIndentStyle IndentPPDirectives;
1379 
1380  /// The number of columns to use for indentation.
1381  /// \code
1382  /// IndentWidth: 3
1383  ///
1384  /// void f() {
1385  /// someFunction();
1386  /// if (true, false) {
1387  /// f();
1388  /// }
1389  /// }
1390  /// \endcode
1391  unsigned IndentWidth;
1392 
1393  /// Indent if a function definition or declaration is wrapped after the
1394  /// type.
1395  /// \code
1396  /// true:
1397  /// LoooooooooooooooooooooooooooooooooooooooongReturnType
1398  /// LoooooooooooooooooooooooooooooooongFunctionDeclaration();
1399  ///
1400  /// false:
1401  /// LoooooooooooooooooooooooooooooooooooooooongReturnType
1402  /// LoooooooooooooooooooooooooooooooongFunctionDeclaration();
1403  /// \endcode
1404  bool IndentWrappedFunctionNames;
1405 
1406  /// A vector of prefixes ordered by the desired groups for Java imports.
1407  ///
1408  /// Each group is separated by a newline. Static imports will also follow the
1409  /// same grouping convention above all non-static imports. One group's prefix
1410  /// can be a subset of another - the longest prefix is always matched. Within
1411  /// a group, the imports are ordered lexicographically.
1412  ///
1413  /// In the .clang-format configuration file, this can be configured like
1414  /// in the following yaml example. This will result in imports being
1415  /// formatted as in the Java example below.
1416  /// \code{.yaml}
1417  /// JavaImportGroups: ['com.example', 'com', 'org']
1418  /// \endcode
1419  ///
1420  /// \code{.java}
1421  /// import static com.example.function1;
1422  ///
1423  /// import static com.test.function2;
1424  ///
1425  /// import static org.example.function3;
1426  ///
1427  /// import com.example.ClassA;
1428  /// import com.example.Test;
1429  /// import com.example.a.ClassB;
1430  ///
1431  /// import com.test.ClassC;
1432  ///
1433  /// import org.example.ClassD;
1434  /// \endcode
1435  std::vector<std::string> JavaImportGroups;
1436 
1437  /// Quotation styles for JavaScript strings. Does not affect template
1438  /// strings.
1439  enum JavaScriptQuoteStyle {
1440  /// Leave string quotes as they are.
1441  /// \code{.js}
1442  /// string1 = "foo";
1443  /// string2 = 'bar';
1444  /// \endcode
1445  JSQS_Leave,
1446  /// Always use single quotes.
1447  /// \code{.js}
1448  /// string1 = 'foo';
1449  /// string2 = 'bar';
1450  /// \endcode
1451  JSQS_Single,
1452  /// Always use double quotes.
1453  /// \code{.js}
1454  /// string1 = "foo";
1455  /// string2 = "bar";
1456  /// \endcode
1457  JSQS_Double
1458  };
1459 
1460  /// The JavaScriptQuoteStyle to use for JavaScript strings.
1461  JavaScriptQuoteStyle JavaScriptQuotes;
1462 
1463  // clang-format off
1464  /// Whether to wrap JavaScript import/export statements.
1465  /// \code{.js}
1466  /// true:
1467  /// import {
1468  /// VeryLongImportsAreAnnoying,
1469  /// VeryLongImportsAreAnnoying,
1470  /// VeryLongImportsAreAnnoying,
1471  /// } from 'some/module.js'
1472  ///
1473  /// false:
1474  /// import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js"
1475  /// \endcode
1476  bool JavaScriptWrapImports;
1477  // clang-format on
1478 
1479  /// If true, the empty line at the start of blocks is kept.
1480  /// \code
1481  /// true: false:
1482  /// if (foo) { vs. if (foo) {
1483  /// bar();
1484  /// bar(); }
1485  /// }
1486  /// \endcode
1487  bool KeepEmptyLinesAtTheStartOfBlocks;
1488 
1489  /// Supported languages.
1490  ///
1491  /// When stored in a configuration file, specifies the language, that the
1492  /// configuration targets. When passed to the ``reformat()`` function, enables
1493  /// syntax features specific to the language.
1494  enum LanguageKind {
1495  /// Do not use.
1496  LK_None,
1497  /// Should be used for C, C++.
1498  LK_Cpp,
1499  /// Should be used for C#.
1500  LK_CSharp,
1501  /// Should be used for Java.
1502  LK_Java,
1503  /// Should be used for JavaScript.
1504  LK_JavaScript,
1505  /// Should be used for Objective-C, Objective-C++.
1506  LK_ObjC,
1507  /// Should be used for Protocol Buffers
1508  /// (https://developers.google.com/protocol-buffers/).
1509  LK_Proto,
1510  /// Should be used for TableGen code.
1511  LK_TableGen,
1512  /// Should be used for Protocol Buffer messages in text format
1513  /// (https://developers.google.com/protocol-buffers/).
1514  LK_TextProto
1515  };
1516  bool isCpp() const { return Language == LK_Cpp || Language == LK_ObjC; }
1517  bool isCSharp() const { return Language == LK_CSharp; }
1518 
1519  /// Language, this format style is targeted at.
1520  LanguageKind Language;
1521 
1522  /// A regular expression matching macros that start a block.
1523  /// \code
1524  /// # With:
1525  /// MacroBlockBegin: "^NS_MAP_BEGIN|\
1526  /// NS_TABLE_HEAD$"
1527  /// MacroBlockEnd: "^\
1528  /// NS_MAP_END|\
1529  /// NS_TABLE_.*_END$"
1530  ///
1531  /// NS_MAP_BEGIN
1532  /// foo();
1533  /// NS_MAP_END
1534  ///
1535  /// NS_TABLE_HEAD
1536  /// bar();
1537  /// NS_TABLE_FOO_END
1538  ///
1539  /// # Without:
1540  /// NS_MAP_BEGIN
1541  /// foo();
1542  /// NS_MAP_END
1543  ///
1544  /// NS_TABLE_HEAD
1545  /// bar();
1546  /// NS_TABLE_FOO_END
1547  /// \endcode
1548  std::string MacroBlockBegin;
1549 
1550  /// A regular expression matching macros that end a block.
1551  std::string MacroBlockEnd;
1552 
1553  /// The maximum number of consecutive empty lines to keep.
1554  /// \code
1555  /// MaxEmptyLinesToKeep: 1 vs. MaxEmptyLinesToKeep: 0
1556  /// int f() { int f() {
1557  /// int = 1; int i = 1;
1558  /// i = foo();
1559  /// i = foo(); return i;
1560  /// }
1561  /// return i;
1562  /// }
1563  /// \endcode
1564  unsigned MaxEmptyLinesToKeep;
1565 
1566  /// Different ways to indent namespace contents.
1567  enum NamespaceIndentationKind {
1568  /// Don't indent in namespaces.
1569  /// \code
1570  /// namespace out {
1571  /// int i;
1572  /// namespace in {
1573  /// int i;
1574  /// }
1575  /// }
1576  /// \endcode
1577  NI_None,
1578  /// Indent only in inner namespaces (nested in other namespaces).
1579  /// \code
1580  /// namespace out {
1581  /// int i;
1582  /// namespace in {
1583  /// int i;
1584  /// }
1585  /// }
1586  /// \endcode
1587  NI_Inner,
1588  /// Indent in all namespaces.
1589  /// \code
1590  /// namespace out {
1591  /// int i;
1592  /// namespace in {
1593  /// int i;
1594  /// }
1595  /// }
1596  /// \endcode
1597  NI_All
1598  };
1599 
1600  /// The indentation used for namespaces.
1601  NamespaceIndentationKind NamespaceIndentation;
1602 
1603  /// Controls bin-packing Objective-C protocol conformance list
1604  /// items into as few lines as possible when they go over ``ColumnLimit``.
1605  ///
1606  /// If ``Auto`` (the default), delegates to the value in
1607  /// ``BinPackParameters``. If that is ``true``, bin-packs Objective-C
1608  /// protocol conformance list items into as few lines as possible
1609  /// whenever they go over ``ColumnLimit``.
1610  ///
1611  /// If ``Always``, always bin-packs Objective-C protocol conformance
1612  /// list items into as few lines as possible whenever they go over
1613  /// ``ColumnLimit``.
1614  ///
1615  /// If ``Never``, lays out Objective-C protocol conformance list items
1616  /// onto individual lines whenever they go over ``ColumnLimit``.
1617  ///
1618  /// \code{.objc}
1619  /// Always (or Auto, if BinPackParameters=true):
1620  /// @interface ccccccccccccc () <
1621  /// ccccccccccccc, ccccccccccccc,
1622  /// ccccccccccccc, ccccccccccccc> {
1623  /// }
1624  ///
1625  /// Never (or Auto, if BinPackParameters=false):
1626  /// @interface ddddddddddddd () <
1627  /// ddddddddddddd,
1628  /// ddddddddddddd,
1629  /// ddddddddddddd,
1630  /// ddddddddddddd> {
1631  /// }
1632  /// \endcode
1633  BinPackStyle ObjCBinPackProtocolList;
1634 
1635  /// The number of characters to use for indentation of ObjC blocks.
1636  /// \code{.objc}
1637  /// ObjCBlockIndentWidth: 4
1638  ///
1639  /// [operation setCompletionBlock:^{
1640  /// [self onOperationDone];
1641  /// }];
1642  /// \endcode
1643  unsigned ObjCBlockIndentWidth;
1644 
1645  /// Add a space after ``@property`` in Objective-C, i.e. use
1646  /// ``@property (readonly)`` instead of ``@property(readonly)``.
1647  bool ObjCSpaceAfterProperty;
1648 
1649  /// Add a space in front of an Objective-C protocol list, i.e. use
1650  /// ``Foo <Protocol>`` instead of ``Foo<Protocol>``.
1651  bool ObjCSpaceBeforeProtocolList;
1652 
1653  /// The penalty for breaking around an assignment operator.
1654  unsigned PenaltyBreakAssignment;
1655 
1656  /// The penalty for breaking a function call after ``call(``.
1657  unsigned PenaltyBreakBeforeFirstCallParameter;
1658 
1659  /// The penalty for each line break introduced inside a comment.
1660  unsigned PenaltyBreakComment;
1661 
1662  /// The penalty for breaking before the first ``<<``.
1663  unsigned PenaltyBreakFirstLessLess;
1664 
1665  /// The penalty for each line break introduced inside a string literal.
1666  unsigned PenaltyBreakString;
1667 
1668  /// The penalty for breaking after template declaration.
1669  unsigned PenaltyBreakTemplateDeclaration;
1670 
1671  /// The penalty for each character outside of the column limit.
1672  unsigned PenaltyExcessCharacter;
1673 
1674  /// Penalty for putting the return type of a function onto its own
1675  /// line.
1676  unsigned PenaltyReturnTypeOnItsOwnLine;
1677 
1678  /// The ``&`` and ``*`` alignment style.
1679  enum PointerAlignmentStyle {
1680  /// Align pointer to the left.
1681  /// \code
1682  /// int* a;
1683  /// \endcode
1684  PAS_Left,
1685  /// Align pointer to the right.
1686  /// \code
1687  /// int *a;
1688  /// \endcode
1689  PAS_Right,
1690  /// Align pointer in the middle.
1691  /// \code
1692  /// int * a;
1693  /// \endcode
1694  PAS_Middle
1695  };
1696 
1697  /// Pointer and reference alignment style.
1698  PointerAlignmentStyle PointerAlignment;
1699 
1700  /// See documentation of ``RawStringFormats``.
1701  struct RawStringFormat {
1702  /// The language of this raw string.
1703  LanguageKind Language;
1704  /// A list of raw string delimiters that match this language.
1705  std::vector<std::string> Delimiters;
1706  /// A list of enclosing function names that match this language.
1707  std::vector<std::string> EnclosingFunctions;
1708  /// The canonical delimiter for this language.
1709  std::string CanonicalDelimiter;
1710  /// The style name on which this raw string format is based on.
1711  /// If not specified, the raw string format is based on the style that this
1712  /// format is based on.
1713  std::string BasedOnStyle;
1714  bool operator==(const RawStringFormat &Other) const {
1715  return Language == Other.Language && Delimiters == Other.Delimiters &&
1716  EnclosingFunctions == Other.EnclosingFunctions &&
1717  CanonicalDelimiter == Other.CanonicalDelimiter &&
1718  BasedOnStyle == Other.BasedOnStyle;
1719  }
1720  };
1721 
1722  /// Defines hints for detecting supported languages code blocks in raw
1723  /// strings.
1724  ///
1725  /// A raw string with a matching delimiter or a matching enclosing function
1726  /// name will be reformatted assuming the specified language based on the
1727  /// style for that language defined in the .clang-format file. If no style has
1728  /// been defined in the .clang-format file for the specific language, a
1729  /// predefined style given by 'BasedOnStyle' is used. If 'BasedOnStyle' is not
1730  /// found, the formatting is based on llvm style. A matching delimiter takes
1731  /// precedence over a matching enclosing function name for determining the
1732  /// language of the raw string contents.
1733  ///
1734  /// If a canonical delimiter is specified, occurrences of other delimiters for
1735  /// the same language will be updated to the canonical if possible.
1736  ///
1737  /// There should be at most one specification per language and each delimiter
1738  /// and enclosing function should not occur in multiple specifications.
1739  ///
1740  /// To configure this in the .clang-format file, use:
1741  /// \code{.yaml}
1742  /// RawStringFormats:
1743  /// - Language: TextProto
1744  /// Delimiters:
1745  /// - 'pb'
1746  /// - 'proto'
1747  /// EnclosingFunctions:
1748  /// - 'PARSE_TEXT_PROTO'
1749  /// BasedOnStyle: google
1750  /// - Language: Cpp
1751  /// Delimiters:
1752  /// - 'cc'
1753  /// - 'cpp'
1754  /// BasedOnStyle: llvm
1755  /// CanonicalDelimiter: 'cc'
1756  /// \endcode
1757  std::vector<RawStringFormat> RawStringFormats;
1758 
1759  // clang-format off
1760  /// If ``true``, clang-format will attempt to re-flow comments.
1761  /// \code
1762  /// false:
1763  /// // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
1764  /// /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */
1765  ///
1766  /// true:
1767  /// // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
1768  /// // information
1769  /// /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
1770  /// * information */
1771  /// \endcode
1772  bool ReflowComments;
1773  // clang-format on
1774 
1775  /// If ``true``, clang-format will sort ``#includes``.
1776  /// \code
1777  /// false: true:
1778  /// #include "b.h" vs. #include "a.h"
1779  /// #include "a.h" #include "b.h"
1780  /// \endcode
1781  bool SortIncludes;
1782 
1783  /// If ``true``, clang-format will sort using declarations.
1784  ///
1785  /// The order of using declarations is defined as follows:
1786  /// Split the strings by "::" and discard any initial empty strings. The last
1787  /// element of each list is a non-namespace name; all others are namespace
1788  /// names. Sort the lists of names lexicographically, where the sort order of
1789  /// individual names is that all non-namespace names come before all namespace
1790  /// names, and within those groups, names are in case-insensitive
1791  /// lexicographic order.
1792  /// \code
1793  /// false: true:
1794  /// using std::cout; vs. using std::cin;
1795  /// using std::cin; using std::cout;
1796  /// \endcode
1797  bool SortUsingDeclarations;
1798 
1799  /// If ``true``, a space is inserted after C style casts.
1800  /// \code
1801  /// true: false:
1802  /// (int) i; vs. (int)i;
1803  /// \endcode
1804  bool SpaceAfterCStyleCast;
1805 
1806  /// If ``true``, a space is inserted after the logical not operator (``!``).
1807  /// \code
1808  /// true: false:
1809  /// ! someExpression(); vs. !someExpression();
1810  /// \endcode
1811  bool SpaceAfterLogicalNot;
1812 
1813  /// If \c true, a space will be inserted after the 'template' keyword.
1814  /// \code
1815  /// true: false:
1816  /// template <int> void foo(); vs. template<int> void foo();
1817  /// \endcode
1818  bool SpaceAfterTemplateKeyword;
1819 
1820  /// If ``false``, spaces will be removed before assignment operators.
1821  /// \code
1822  /// true: false:
1823  /// int a = 5; vs. int a= 5;
1824  /// a += 42; a+= 42;
1825  /// \endcode
1826  bool SpaceBeforeAssignmentOperators;
1827 
1828  /// If ``true``, a space will be inserted before a C++11 braced list
1829  /// used to initialize an object (after the preceding identifier or type).
1830  /// \code
1831  /// true: false:
1832  /// Foo foo { bar }; vs. Foo foo{ bar };
1833  /// Foo {}; Foo{};
1834  /// vector<int> { 1, 2, 3 }; vector<int>{ 1, 2, 3 };
1835  /// new int[3] { 1, 2, 3 }; new int[3]{ 1, 2, 3 };
1836  /// \endcode
1837  bool SpaceBeforeCpp11BracedList;
1838 
1839  /// If ``false``, spaces will be removed before constructor initializer
1840  /// colon.
1841  /// \code
1842  /// true: false:
1843  /// Foo::Foo() : a(a) {} Foo::Foo(): a(a) {}
1844  /// \endcode
1845  bool SpaceBeforeCtorInitializerColon;
1846 
1847  /// If ``false``, spaces will be removed before inheritance colon.
1848  /// \code
1849  /// true: false:
1850  /// class Foo : Bar {} vs. class Foo: Bar {}
1851  /// \endcode
1852  bool SpaceBeforeInheritanceColon;
1853 
1854  /// Different ways to put a space before opening parentheses.
1855  enum SpaceBeforeParensOptions {
1856  /// Never put a space before opening parentheses.
1857  /// \code
1858  /// void f() {
1859  /// if(true) {
1860  /// f();
1861  /// }
1862  /// }
1863  /// \endcode
1864  SBPO_Never,
1865  /// Put a space before opening parentheses only after control statement
1866  /// keywords (``for/if/while...``).
1867  /// \code
1868  /// void f() {
1869  /// if (true) {
1870  /// f();
1871  /// }
1872  /// }
1873  /// \endcode
1874  SBPO_ControlStatements,
1875  /// Put a space before opening parentheses only if the parentheses are not
1876  /// empty i.e. '()'
1877  /// \code
1878  /// void() {
1879  /// if (true) {
1880  /// f();
1881  /// g (x, y, z);
1882  /// }
1883  /// }
1884  /// \endcode
1885  SBPO_NonEmptyParentheses,
1886  /// Always put a space before opening parentheses, except when it's
1887  /// prohibited by the syntax rules (in function-like macro definitions) or
1888  /// when determined by other style rules (after unary operators, opening
1889  /// parentheses, etc.)
1890  /// \code
1891  /// void f () {
1892  /// if (true) {
1893  /// f ();
1894  /// }
1895  /// }
1896  /// \endcode
1897  SBPO_Always
1898  };
1899 
1900  /// Defines in which cases to put a space before opening parentheses.
1901  SpaceBeforeParensOptions SpaceBeforeParens;
1902 
1903  /// If ``false``, spaces will be removed before range-based for loop
1904  /// colon.
1905  /// \code
1906  /// true: false:
1907  /// for (auto v : values) {} vs. for(auto v: values) {}
1908  /// \endcode
1909  bool SpaceBeforeRangeBasedForLoopColon;
1910 
1911  /// If ``true``, spaces will be inserted into ``{}``.
1912  /// \code
1913  /// true: false:
1914  /// void f() { } vs. void f() {}
1915  /// while (true) { } while (true) {}
1916  /// \endcode
1917  bool SpaceInEmptyBlock;
1918 
1919  /// If ``true``, spaces may be inserted into ``()``.
1920  /// \code
1921  /// true: false:
1922  /// void f( ) { vs. void f() {
1923  /// int x[] = {foo( ), bar( )}; int x[] = {foo(), bar()};
1924  /// if (true) { if (true) {
1925  /// f( ); f();
1926  /// } }
1927  /// } }
1928  /// \endcode
1929  bool SpaceInEmptyParentheses;
1930 
1931  /// The number of spaces before trailing line comments
1932  /// (``//`` - comments).
1933  ///
1934  /// This does not affect trailing block comments (``/*`` - comments) as
1935  /// those commonly have different usage patterns and a number of special
1936  /// cases.
1937  /// \code
1938  /// SpacesBeforeTrailingComments: 3
1939  /// void f() {
1940  /// if (true) { // foo1
1941  /// f(); // bar
1942  /// } // foo
1943  /// }
1944  /// \endcode
1945  unsigned SpacesBeforeTrailingComments;
1946 
1947  /// If ``true``, spaces will be inserted after ``<`` and before ``>``
1948  /// in template argument lists.
1949  /// \code
1950  /// true: false:
1951  /// static_cast< int >(arg); vs. static_cast<int>(arg);
1952  /// std::function< void(int) > fct; std::function<void(int)> fct;
1953  /// \endcode
1954  bool SpacesInAngles;
1955 
1956  /// If ``true``, spaces will be inserted around if/for/switch/while
1957  /// conditions.
1958  /// \code
1959  /// true: false:
1960  /// if ( a ) { ... } vs. if (a) { ... }
1961  /// while ( i < 5 ) { ... } while (i < 5) { ... }
1962  /// \endcode
1963  bool SpacesInConditionalStatement;
1964 
1965  /// If ``true``, spaces are inserted inside container literals (e.g.
1966  /// ObjC and Javascript array and dict literals).
1967  /// \code{.js}
1968  /// true: false:
1969  /// var arr = [ 1, 2, 3 ]; vs. var arr = [1, 2, 3];
1970  /// f({a : 1, b : 2, c : 3}); f({a: 1, b: 2, c: 3});
1971  /// \endcode
1972  bool SpacesInContainerLiterals;
1973 
1974  /// If ``true``, spaces may be inserted into C style casts.
1975  /// \code
1976  /// true: false:
1977  /// x = ( int32 )y vs. x = (int32)y
1978  /// \endcode
1979  bool SpacesInCStyleCastParentheses;
1980 
1981  /// If ``true``, spaces will be inserted after ``(`` and before ``)``.
1982  /// \code
1983  /// true: false:
1984  /// t f( Deleted & ) & = delete; vs. t f(Deleted &) & = delete;
1985  /// \endcode
1986  bool SpacesInParentheses;
1987 
1988  /// If ``true``, spaces will be inserted after ``[`` and before ``]``.
1989  /// Lambdas without arguments or unspecified size array declarations will not
1990  /// be affected.
1991  /// \code
1992  /// true: false:
1993  /// int a[ 5 ]; vs. int a[5];
1994  /// std::unique_ptr<int[]> foo() {} // Won't be affected
1995  /// \endcode
1996  bool SpacesInSquareBrackets;
1997 
1998  /// If ``true``, spaces will be before ``[``.
1999  /// Lambdas will not be affected. Only the first ``[`` will get a space added.
2000  /// \code
2001  /// true: false:
2002  /// int a [5]; vs. int a[5];
2003  /// int a [5][5]; vs. int a[5][5];
2004  /// \endcode
2005  bool SpaceBeforeSquareBrackets;
2006 
2007  /// Supported language standards for parsing and formatting C++ constructs.
2008  /// \code
2009  /// Latest: vector<set<int>>
2010  /// c++03 vs. vector<set<int> >
2011  /// \endcode
2012  ///
2013  /// The correct way to spell a specific language version is e.g. ``c++11``.
2014  /// The historical aliases ``Cpp03`` and ``Cpp11`` are deprecated.
2015  enum LanguageStandard {
2016  /// Parse and format as C++03.
2017  /// ``Cpp03`` is a deprecated alias for ``c++03``
2018  LS_Cpp03, // c++03
2019  /// Parse and format as C++11.
2020  LS_Cpp11, // c++11
2021  /// Parse and format as C++14.
2022  LS_Cpp14, // c++14
2023  /// Parse and format as C++17.
2024  LS_Cpp17, // c++17
2025  /// Parse and format as C++20.
2026  LS_Cpp20, // c++20
2027  /// Parse and format using the latest supported language version.
2028  /// ``Cpp11`` is a deprecated alias for ``Latest``
2029  LS_Latest,
2030  /// Automatic detection based on the input.
2031  LS_Auto,
2032  };
2033 
2034  /// Parse and format C++ constructs compatible with this standard.
2035  /// \code
2036  /// c++03: latest:
2037  /// vector<set<int> > x; vs. vector<set<int>> x;
2038  /// \endcode
2039  LanguageStandard Standard;
2040 
2041  /// The number of columns used for tab stops.
2042  unsigned TabWidth;
2043 
2044  /// Different ways to use tab in formatting.
2045  enum UseTabStyle {
2046  /// Never use tab.
2047  UT_Never,
2048  /// Use tabs only for indentation.
2049  UT_ForIndentation,
2050  /// Use tabs only for line continuation and indentation.
2051  UT_ForContinuationAndIndentation,
2052  /// Use tabs whenever we need to fill whitespace that spans at least from
2053  /// one tab stop to the next one.
2054  UT_Always
2055  };
2056 
2057  /// \brief Use ``\r\n`` instead of ``\n`` for line breaks.
2058  /// Also used as fallback if ``DeriveLineEnding`` is true.
2059  bool UseCRLF;
2060 
2061  /// The way to use tab characters in the resulting file.
2062  UseTabStyle UseTab;
2063 
2064  bool operator==(const FormatStyle &R) const {
2065  return AccessModifierOffset == R.AccessModifierOffset &&
2066  AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
2067  AlignConsecutiveAssignments == R.AlignConsecutiveAssignments &&
2068  AlignConsecutiveDeclarations == R.AlignConsecutiveDeclarations &&
2069  AlignEscapedNewlines == R.AlignEscapedNewlines &&
2070  AlignOperands == R.AlignOperands &&
2071  AlignTrailingComments == R.AlignTrailingComments &&
2072  AllowAllArgumentsOnNextLine == R.AllowAllArgumentsOnNextLine &&
2073  AllowAllConstructorInitializersOnNextLine ==
2074  R.AllowAllConstructorInitializersOnNextLine &&
2075  AllowAllParametersOfDeclarationOnNextLine ==
2076  R.AllowAllParametersOfDeclarationOnNextLine &&
2077  AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine &&
2078  AllowShortCaseLabelsOnASingleLine ==
2079  R.AllowShortCaseLabelsOnASingleLine &&
2080  AllowShortFunctionsOnASingleLine ==
2081  R.AllowShortFunctionsOnASingleLine &&
2082  AllowShortIfStatementsOnASingleLine ==
2083  R.AllowShortIfStatementsOnASingleLine &&
2084  AllowShortLambdasOnASingleLine == R.AllowShortLambdasOnASingleLine &&
2085  AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine &&
2086  AlwaysBreakAfterReturnType == R.AlwaysBreakAfterReturnType &&
2087  AlwaysBreakBeforeMultilineStrings ==
2088  R.AlwaysBreakBeforeMultilineStrings &&
2089  AlwaysBreakTemplateDeclarations ==
2090  R.AlwaysBreakTemplateDeclarations &&
2091  BinPackArguments == R.BinPackArguments &&
2092  BinPackParameters == R.BinPackParameters &&
2093  BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators &&
2094  BreakBeforeBraces == R.BreakBeforeBraces &&
2095  BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators &&
2096  BreakConstructorInitializers == R.BreakConstructorInitializers &&
2097  CompactNamespaces == R.CompactNamespaces &&
2098  BreakAfterJavaFieldAnnotations == R.BreakAfterJavaFieldAnnotations &&
2099  BreakStringLiterals == R.BreakStringLiterals &&
2100  ColumnLimit == R.ColumnLimit && CommentPragmas == R.CommentPragmas &&
2101  BreakInheritanceList == R.BreakInheritanceList &&
2102  ConstructorInitializerAllOnOneLineOrOnePerLine ==
2103  R.ConstructorInitializerAllOnOneLineOrOnePerLine &&
2104  ConstructorInitializerIndentWidth ==
2105  R.ConstructorInitializerIndentWidth &&
2106  ContinuationIndentWidth == R.ContinuationIndentWidth &&
2107  Cpp11BracedListStyle == R.Cpp11BracedListStyle &&
2108  DeriveLineEnding == R.DeriveLineEnding &&
2109  DerivePointerAlignment == R.DerivePointerAlignment &&
2110  DisableFormat == R.DisableFormat &&
2111  ExperimentalAutoDetectBinPacking ==
2112  R.ExperimentalAutoDetectBinPacking &&
2113  FixNamespaceComments == R.FixNamespaceComments &&
2114  ForEachMacros == R.ForEachMacros &&
2115  IncludeStyle.IncludeBlocks == R.IncludeStyle.IncludeBlocks &&
2116  IncludeStyle.IncludeCategories == R.IncludeStyle.IncludeCategories &&
2117  IncludeStyle.IncludeIsMainRegex ==
2118  R.IncludeStyle.IncludeIsMainRegex &&
2119  IncludeStyle.IncludeIsMainSourceRegex ==
2120  R.IncludeStyle.IncludeIsMainSourceRegex &&
2121  IndentCaseLabels == R.IndentCaseLabels &&
2122  IndentGotoLabels == R.IndentGotoLabels &&
2123  IndentPPDirectives == R.IndentPPDirectives &&
2124  IndentWidth == R.IndentWidth && Language == R.Language &&
2125  IndentWrappedFunctionNames == R.IndentWrappedFunctionNames &&
2126  JavaImportGroups == R.JavaImportGroups &&
2127  JavaScriptQuotes == R.JavaScriptQuotes &&
2128  JavaScriptWrapImports == R.JavaScriptWrapImports &&
2129  KeepEmptyLinesAtTheStartOfBlocks ==
2130  R.KeepEmptyLinesAtTheStartOfBlocks &&
2131  MacroBlockBegin == R.MacroBlockBegin &&
2132  MacroBlockEnd == R.MacroBlockEnd &&
2133  MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep &&
2134  NamespaceIndentation == R.NamespaceIndentation &&
2135  NamespaceMacros == R.NamespaceMacros &&
2136  ObjCBinPackProtocolList == R.ObjCBinPackProtocolList &&
2137  ObjCBlockIndentWidth == R.ObjCBlockIndentWidth &&
2138  ObjCSpaceAfterProperty == R.ObjCSpaceAfterProperty &&
2139  ObjCSpaceBeforeProtocolList == R.ObjCSpaceBeforeProtocolList &&
2140  PenaltyBreakAssignment == R.PenaltyBreakAssignment &&
2141  PenaltyBreakBeforeFirstCallParameter ==
2142  R.PenaltyBreakBeforeFirstCallParameter &&
2143  PenaltyBreakComment == R.PenaltyBreakComment &&
2144  PenaltyBreakFirstLessLess == R.PenaltyBreakFirstLessLess &&
2145  PenaltyBreakString == R.PenaltyBreakString &&
2146  PenaltyExcessCharacter == R.PenaltyExcessCharacter &&
2147  PenaltyReturnTypeOnItsOwnLine == R.PenaltyReturnTypeOnItsOwnLine &&
2148  PenaltyBreakTemplateDeclaration ==
2149  R.PenaltyBreakTemplateDeclaration &&
2150  PointerAlignment == R.PointerAlignment &&
2151  RawStringFormats == R.RawStringFormats &&
2152  SpaceAfterCStyleCast == R.SpaceAfterCStyleCast &&
2153  SpaceAfterLogicalNot == R.SpaceAfterLogicalNot &&
2154  SpaceAfterTemplateKeyword == R.SpaceAfterTemplateKeyword &&
2155  SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators &&
2156  SpaceBeforeCpp11BracedList == R.SpaceBeforeCpp11BracedList &&
2157  SpaceBeforeCtorInitializerColon ==
2158  R.SpaceBeforeCtorInitializerColon &&
2159  SpaceBeforeInheritanceColon == R.SpaceBeforeInheritanceColon &&
2160  SpaceBeforeParens == R.SpaceBeforeParens &&
2161  SpaceBeforeRangeBasedForLoopColon ==
2162  R.SpaceBeforeRangeBasedForLoopColon &&
2163  SpaceInEmptyBlock == R.SpaceInEmptyBlock &&
2164  SpaceInEmptyParentheses == R.SpaceInEmptyParentheses &&
2165  SpacesBeforeTrailingComments == R.SpacesBeforeTrailingComments &&
2166  SpacesInAngles == R.SpacesInAngles &&
2167  SpacesInConditionalStatement == R.SpacesInConditionalStatement &&
2168  SpacesInContainerLiterals == R.SpacesInContainerLiterals &&
2169  SpacesInCStyleCastParentheses == R.SpacesInCStyleCastParentheses &&
2170  SpacesInParentheses == R.SpacesInParentheses &&
2171  SpacesInSquareBrackets == R.SpacesInSquareBrackets &&
2172  SpaceBeforeSquareBrackets == R.SpaceBeforeSquareBrackets &&
2173  Standard == R.Standard && TabWidth == R.TabWidth &&
2174  StatementMacros == R.StatementMacros && UseTab == R.UseTab &&
2175  UseCRLF == R.UseCRLF && TypenameMacros == R.TypenameMacros;
2176  }
2177 
2178  llvm::Optional<FormatStyle> GetLanguageStyle(LanguageKind Language) const;
2179 
2180  // Stores per-language styles. A FormatStyle instance inside has an empty
2181  // StyleSet. A FormatStyle instance returned by the Get method has its
2182  // StyleSet set to a copy of the originating StyleSet, effectively keeping the
2183  // internal representation of that StyleSet alive.
2184  //
2185  // The memory management and ownership reminds of a birds nest: chicks
2186  // leaving the nest take photos of the nest with them.
2187  struct FormatStyleSet {
2188  typedef std::map<FormatStyle::LanguageKind, FormatStyle> MapType;
2189 
2190  llvm::Optional<FormatStyle> Get(FormatStyle::LanguageKind Language) const;
2191 
2192  // Adds \p Style to this FormatStyleSet. Style must not have an associated
2193  // FormatStyleSet.
2194  // Style.Language should be different than LK_None. If this FormatStyleSet
2195  // already contains an entry for Style.Language, that gets replaced with the
2196  // passed Style.
2197  void Add(FormatStyle Style);
2198 
2199  // Clears this FormatStyleSet.
2200  void Clear();
2201 
2202  private:
2203  std::shared_ptr<MapType> Styles;
2204  };
2205 
2206  static FormatStyleSet BuildStyleSetFromConfiguration(
2207  const FormatStyle &MainStyle,
2208  const std::vector<FormatStyle> &ConfigurationStyles);
2209 
2210 private:
2211  FormatStyleSet StyleSet;
2212 
2213  friend std::error_code parseConfiguration(StringRef Text, FormatStyle *Style);
2214 };
2215 
2216 /// Returns a format style complying with the LLVM coding standards:
2217 /// http://llvm.org/docs/CodingStandards.html.
2219  FormatStyle::LanguageKind Language = FormatStyle::LanguageKind::LK_Cpp);
2220 
2221 /// Returns a format style complying with one of Google's style guides:
2222 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml.
2223 /// http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml.
2224 /// https://developers.google.com/protocol-buffers/docs/style.
2225 FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language);
2226 
2227 /// Returns a format style complying with Chromium's style guide:
2228 /// http://www.chromium.org/developers/coding-style.
2229 FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language);
2230 
2231 /// Returns a format style complying with Mozilla's style guide:
2232 /// https://developer.mozilla.org/en-US/docs/Developer_Guide/Coding_Style.
2234 
2235 /// Returns a format style complying with Webkit's style guide:
2236 /// http://www.webkit.org/coding/coding-style.html
2238 
2239 /// Returns a format style complying with GNU Coding Standards:
2240 /// http://www.gnu.org/prep/standards/standards.html
2242 
2243 /// Returns a format style complying with Microsoft style guide:
2244 /// https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference?view=vs-2017
2245 FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language);
2246 
2247 /// Returns style indicating formatting should be not applied at all.
2249 
2250 /// Gets a predefined style for the specified language by name.
2251 ///
2252 /// Currently supported names: LLVM, Google, Chromium, Mozilla. Names are
2253 /// compared case-insensitively.
2254 ///
2255 /// Returns ``true`` if the Style has been set.
2256 bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
2257  FormatStyle *Style);
2258 
2259 /// Parse configuration from YAML-formatted text.
2260 ///
2261 /// Style->Language is used to get the base style, if the ``BasedOnStyle``
2262 /// option is present.
2263 ///
2264 /// The FormatStyleSet of Style is reset.
2265 ///
2266 /// When ``BasedOnStyle`` is not present, options not present in the YAML
2267 /// document, are retained in \p Style.
2268 std::error_code parseConfiguration(StringRef Text, FormatStyle *Style);
2269 
2270 /// Gets configuration in a YAML string.
2271 std::string configurationAsText(const FormatStyle &Style);
2272 
2273 /// Returns the replacements necessary to sort all ``#include`` blocks
2274 /// that are affected by ``Ranges``.
2275 tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
2276  ArrayRef<tooling::Range> Ranges,
2277  StringRef FileName,
2278  unsigned *Cursor = nullptr);
2279 
2280 /// Returns the replacements corresponding to applying and formatting
2281 /// \p Replaces on success; otheriwse, return an llvm::Error carrying
2282 /// llvm::StringError.
2284 formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
2285  const FormatStyle &Style);
2286 
2287 /// Returns the replacements corresponding to applying \p Replaces and
2288 /// cleaning up the code after that on success; otherwise, return an llvm::Error
2289 /// carrying llvm::StringError.
2290 /// This also supports inserting/deleting C++ #include directives:
2291 /// - If a replacement has offset UINT_MAX, length 0, and a replacement text
2292 /// that is an #include directive, this will insert the #include into the
2293 /// correct block in the \p Code.
2294 /// - If a replacement has offset UINT_MAX, length 1, and a replacement text
2295 /// that is the name of the header to be removed, the header will be removed
2296 /// from \p Code if it exists.
2297 /// The include manipulation is done via `tooling::HeaderInclude`, see its
2298 /// documentation for more details on how include insertion points are found and
2299 /// what edits are produced.
2301 cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
2302  const FormatStyle &Style);
2303 
2304 /// Represents the status of a formatting attempt.
2306  /// A value of ``false`` means that any of the affected ranges were not
2307  /// formatted due to a non-recoverable syntax error.
2308  bool FormatComplete = true;
2309 
2310  /// If ``FormatComplete`` is false, ``Line`` records a one-based
2311  /// original line number at which a syntax error might have occurred. This is
2312  /// based on a best-effort analysis and could be imprecise.
2313  unsigned Line = 0;
2314 };
2315 
2316 /// Reformats the given \p Ranges in \p Code.
2317 ///
2318 /// Each range is extended on either end to its next bigger logic unit, i.e.
2319 /// everything that might influence its formatting or might be influenced by its
2320 /// formatting.
2321 ///
2322 /// Returns the ``Replacements`` necessary to make all \p Ranges comply with
2323 /// \p Style.
2324 ///
2325 /// If ``Status`` is non-null, its value will be populated with the status of
2326 /// this formatting attempt. See \c FormattingAttemptStatus.
2327 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
2328  ArrayRef<tooling::Range> Ranges,
2329  StringRef FileName = "<stdin>",
2330  FormattingAttemptStatus *Status = nullptr);
2331 
2332 /// Same as above, except if ``IncompleteFormat`` is non-null, its value
2333 /// will be set to true if any of the affected ranges were not formatted due to
2334 /// a non-recoverable syntax error.
2335 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
2336  ArrayRef<tooling::Range> Ranges,
2337  StringRef FileName, bool *IncompleteFormat);
2338 
2339 /// Clean up any erroneous/redundant code in the given \p Ranges in \p
2340 /// Code.
2341 ///
2342 /// Returns the ``Replacements`` that clean up all \p Ranges in \p Code.
2343 tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
2344  ArrayRef<tooling::Range> Ranges,
2345  StringRef FileName = "<stdin>");
2346 
2347 /// Fix namespace end comments in the given \p Ranges in \p Code.
2348 ///
2349 /// Returns the ``Replacements`` that fix the namespace comments in all
2350 /// \p Ranges in \p Code.
2352  StringRef Code,
2353  ArrayRef<tooling::Range> Ranges,
2354  StringRef FileName = "<stdin>");
2355 
2356 /// Sort consecutive using declarations in the given \p Ranges in
2357 /// \p Code.
2358 ///
2359 /// Returns the ``Replacements`` that sort the using declarations in all
2360 /// \p Ranges in \p Code.
2362  StringRef Code,
2363  ArrayRef<tooling::Range> Ranges,
2364  StringRef FileName = "<stdin>");
2365 
2366 /// Returns the ``LangOpts`` that the formatter expects you to set.
2367 ///
2368 /// \param Style determines specific settings for lexing mode.
2370 
2371 /// Description to be used for help text for a ``llvm::cl`` option for
2372 /// specifying format style. The description is closely related to the operation
2373 /// of ``getStyle()``.
2374 extern const char *StyleOptionHelpDescription;
2375 
2376 /// The suggested format style to use by default. This allows tools using
2377 /// `getStyle` to have a consistent default style.
2378 /// Different builds can modify the value to the preferred styles.
2379 extern const char *DefaultFormatStyle;
2380 
2381 /// The suggested predefined style to use as the fallback style in `getStyle`.
2382 /// Different builds can modify the value to the preferred styles.
2383 extern const char *DefaultFallbackStyle;
2384 
2385 /// Construct a FormatStyle based on ``StyleName``.
2386 ///
2387 /// ``StyleName`` can take several forms:
2388 /// * "{<key>: <value>, ...}" - Set specic style parameters.
2389 /// * "<style name>" - One of the style names supported by
2390 /// getPredefinedStyle().
2391 /// * "file" - Load style configuration from a file called ``.clang-format``
2392 /// located in one of the parent directories of ``FileName`` or the current
2393 /// directory if ``FileName`` is empty.
2394 ///
2395 /// \param[in] StyleName Style name to interpret according to the description
2396 /// above.
2397 /// \param[in] FileName Path to start search for .clang-format if ``StyleName``
2398 /// == "file".
2399 /// \param[in] FallbackStyle The name of a predefined style used to fallback to
2400 /// in case \p StyleName is "file" and no file can be found.
2401 /// \param[in] Code The actual code to be formatted. Used to determine the
2402 /// language if the filename isn't sufficient.
2403 /// \param[in] FS The underlying file system, in which the file resides. By
2404 /// default, the file system is the real file system.
2405 ///
2406 /// \returns FormatStyle as specified by ``StyleName``. If ``StyleName`` is
2407 /// "file" and no file is found, returns ``FallbackStyle``. If no style could be
2408 /// determined, returns an Error.
2409 llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
2410  StringRef FallbackStyle,
2411  StringRef Code = "",
2412  llvm::vfs::FileSystem *FS = nullptr);
2413 
2414 // Guesses the language from the ``FileName`` and ``Code`` to be formatted.
2415 // Defaults to FormatStyle::LK_Cpp.
2416 FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code);
2417 
2418 // Returns a string representation of ``Language``.
2419 inline StringRef getLanguageName(FormatStyle::LanguageKind Language) {
2420  switch (Language) {
2421  case FormatStyle::LK_Cpp:
2422  return "C++";
2423  case FormatStyle::LK_CSharp:
2424  return "CSharp";
2425  case FormatStyle::LK_ObjC:
2426  return "Objective-C";
2427  case FormatStyle::LK_Java:
2428  return "Java";
2429  case FormatStyle::LK_JavaScript:
2430  return "JavaScript";
2431  case FormatStyle::LK_Proto:
2432  return "Proto";
2433  case FormatStyle::LK_TableGen:
2434  return "TableGen";
2435  case FormatStyle::LK_TextProto:
2436  return "TextProto";
2437  default:
2438  return "Unknown";
2439  }
2440 }
2441 
2442 } // end namespace format
2443 } // end namespace clang
2444 
2445 namespace std {
2446 template <>
2447 struct is_error_code_enum<clang::format::ParseError> : std::true_type {};
2448 } // namespace std
2449 
2450 #endif // LLVM_CLANG_FORMAT_FORMAT_H
bool operator==(CanQual< T > x, CanQual< U > y)
tooling::Replacements reformat(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName, bool *IncompleteFormat)
Same as above, except if IncompleteFormat is non-null, its value will be set to true if any of the af...
Definition: Format.cpp:2481
Specialize PointerLikeTypeTraits to allow LazyGenerationalUpdatePtr to be placed into a PointerUnion...
Definition: Dominators.h:30
tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName, unsigned *Cursor=nullptr)
Returns the replacements necessary to sort all #include blocks that are affected by Ranges...
Definition: Format.cpp:2228
tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName="<stdin>")
Clean up any erroneous/redundant code in the given Ranges in Code.
Definition: Format.cpp:2472
bool AlignConsecutiveDeclarations
If true, aligns consecutive declarations.
Definition: Format.h:115
FormatStyle getMozillaStyle()
Returns a format style complying with Mozilla&#39;s style guide: https://developer.mozilla.org/en-US/docs/Developer_Guide/Coding_Style.
Definition: Format.cpp:1034
std::error_code make_error_code(ParseError e)
Definition: Format.cpp:625
std::vector< IncludeCategory > IncludeCategories
Regular expressions denoting the different #include categories used for ordering #includes.
Definition: IncludeStyle.h:109
Maintains a set of replacements that are conflict-free.
Definition: Replacement.h:209
tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName="<stdin>")
Fix namespace end comments in the given Ranges in Code.
Definition: Format.cpp:2491
FormatStyle getWebKitStyle()
Returns a format style complying with Webkit&#39;s style guide: http://www.webkit.org/coding/coding-style...
Definition: Format.cpp:1060
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language=FormatStyle::LanguageKind::LK_Cpp)
Returns a format style complying with the LLVM coding standards: http://llvm.org/docs/CodingStandards...
Definition: Format.cpp:725
EscapedNewlineAlignmentStyle AlignEscapedNewlines
Options for aligning backslashes in escaped newlines.
Definition: Format.h:149
Definition: Format.h:2445
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:53
Always break after an open bracket, if the parameters don&#39;t fit on a single line, e...
Definition: Format.h:73
FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code)
Definition: Format.cpp:2567
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr or CxxCtorInitializer) selects the name&#39;s to...
llvm::Error Error
FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language)
Returns a format style complying with Chromium&#39;s style guide: http://www.chromium.org/developers/coding-style.
Definition: Format.cpp:974
FormatStyle getGNUStyle()
Returns a format style complying with GNU Coding Standards: http://www.gnu.org/prep/standards/standar...
Definition: Format.cpp:1083
bool AlignConsecutiveAssignments
If true, aligns consecutive assignments.
Definition: Format.h:104
Language
The language for the input, used to select and validate the language standard and possible actions...
Definition: LangStandard.h:19
llvm::Expected< tooling::Replacements > formatReplacements(StringRef Code, const tooling::Replacements &Replaces, const FormatStyle &Style)
Returns the replacements corresponding to applying and formatting Replaces on success; otheriwse...
Definition: Format.cpp:2268
BracketAlignmentStyle AlignAfterOpenBracket
If true, horizontally aligns arguments after an open bracket.
Definition: Format.h:80
tooling::Replacements sortUsingDeclarations(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName="<stdin>")
Sort consecutive using declarations in the given Ranges in Code.
Definition: Format.cpp:2500
Defines the clang::LangOptions interface.
const AnnotatedLine * Line
LangOptions getFormattingLangOpts(const FormatStyle &Style=getLLVMStyle())
Returns the LangOpts that the formatter expects you to set.
Definition: Format.cpp:2509
Align escaped newlines as far left as possible.
Definition: Format.h:137
Align escaped newlines in the right-most column.
Definition: Format.h:145
bool AlignOperands
If true, horizontally align operands of binary and ternary expressions.
Definition: Format.h:160
Don&#39;t align escaped newlines.
Definition: Format.h:126
int AccessModifierOffset
The extra indent or outdent of access modifiers, e.g. public:.
Definition: Format.h:51
FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language)
Returns a format style complying with one of Google&#39;s style guides: http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml.
Definition: Format.cpp:847
EscapedNewlineAlignmentStyle
Different styles for aligning escaped newlines.
Definition: Format.h:118
const char * DefaultFallbackStyle
The suggested predefined style to use as the fallback style in getStyle.
Definition: Format.cpp:2587
llvm::Expected< tooling::Replacements > cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces, const FormatStyle &Style)
Returns the replacements corresponding to applying Replaces and cleaning up the code after that on su...
Definition: Format.cpp:2378
StringRef getLanguageName(FormatStyle::LanguageKind Language)
Definition: Format.h:2419
Don&#39;t align, instead use ContinuationIndentWidth, e.g.
Definition: Format.h:66
FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language)
Returns a format style complying with Microsoft style guide: https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference?view=vs-2017.
Definition: Format.cpp:1098
std::string IncludeIsMainSourceRegex
Specify a regular expression for files being formatted that are allowed to be considered "main" in th...
Definition: IncludeStyle.h:142
const char * DefaultFormatStyle
The suggested format style to use by default.
Definition: Format.cpp:2585
The FormatStyle is used to configure the formatting to follow specific guidelines.
Definition: Format.h:49
Style for sorting and grouping C++ #include directives.
Definition: IncludeStyle.h:20
std::string configurationAsText(const FormatStyle &Style)
Gets configuration in a YAML string.
Definition: Format.cpp:1213
const char * StyleOptionHelpDescription
Description to be used for help text for a llvm::cl option for specifying format style.
Definition: Format.cpp:2533
Represents the status of a formatting attempt.
Definition: Format.h:2305
Dataflow Directional Tag Classes.
BracketAlignmentStyle
Different styles for aligning after open brackets.
Definition: Format.h:54
bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language, FormatStyle *Style)
Gets a predefined style for the specified language by name.
Definition: Format.cpp:1133
bool AlignConsecutiveMacros
If true, aligns consecutive C/C++ preprocessor macros.
Definition: Format.h:93
std::string IncludeIsMainRegex
Specify a regular expression of suffixes that are allowed in the file-to-main-include mapping...
Definition: IncludeStyle.h:122
FormatStyle getNoStyle()
Returns style indicating formatting should be not applied at all.
Definition: Format.cpp:1125
Align parameters on the open bracket, e.g.
Definition: Format.h:60
const std::error_category & getParseCategory()
Definition: Format.cpp:621
llvm::Expected< FormatStyle > getStyle(StringRef StyleName, StringRef FileName, StringRef FallbackStyle, StringRef Code="", llvm::vfs::FileSystem *FS=nullptr)
Construct a FormatStyle based on StyleName.
Definition: Format.cpp:2589
bool Add(InterpState &S, CodePtr OpPC)
Definition: Interp.h:132
bool AlignTrailingComments
If true, aligns trailing comments.
Definition: Format.h:168
StringRef Text
Definition: Format.cpp:1826
std::error_code parseConfiguration(StringRef Text, FormatStyle *Style)
Parse configuration from YAML-formatted text.
Definition: Format.cpp:1159
IncludeBlocksStyle IncludeBlocks
Dependent on the value, multiple #include blocks can be sorted as one and divided based on category...
Definition: IncludeStyle.h:53
bool AllowAllArgumentsOnNextLine
If a function call or braced initializer list doesn&#39;t fit on a line, allow putting all arguments onto...
Definition: Format.h:184
const FormatStyle & Style