Coverage Report

Created: 2022-07-16 07:03

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Format/Format.h
Line
Count
Source (jump to first uncovered line)
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
290
    bool operator==(const AlignConsecutiveStyle &R) const {
244
290
      return Enabled == R.Enabled && 
AcrossEmptyLines == R.AcrossEmptyLines274
&&
245
290
             
AcrossComments == R.AcrossComments270
&&
246
290
             
AlignCompound == R.AlignCompound266
&&
PadOperators == R.PadOperators266
;
247
290
    }
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 7
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
3.77M
  bool isCpp() const { return Language == LK_Cpp || 
Language == LK_ObjC1.28M
; }
2599
5.69M
  bool isCSharp() const { return Language == LK_CSharp; }
2600
547k
  bool isJson() const { return Language == LK_Json; }
2601
25.3M
  bool isJavaScript() const { return Language == LK_JavaScript; }
2602
3.96M
  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
46
    bool operator==(const RawStringFormat &Other) const {
2899
46
      return Language == Other.Language && Delimiters == Other.Delimiters &&
2900
46
             EnclosingFunctions == Other.EnclosingFunctions &&
2901
46
             CanonicalDelimiter == Other.CanonicalDelimiter &&
2902
46
             BasedOnStyle == Other.BasedOnStyle;
2903
46
    }
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
63.5k
          AfterRequiresInExpression(false), BeforeNonEmptyParentheses(false) {}
3540
3541
44
    bool operator==(const SpaceBeforeParensCustom &Other) const {
3542
44
      return AfterControlStatements == Other.AfterControlStatements &&
3543
44
             AfterForeachMacros == Other.AfterForeachMacros &&
3544
44
             AfterFunctionDeclarationName ==
3545
44
                 Other.AfterFunctionDeclarationName &&
3546
44
             AfterFunctionDefinitionName == Other.AfterFunctionDefinitionName &&
3547
44
             AfterIfMacros == Other.AfterIfMacros &&
3548
44
             AfterOverloadedOperator == Other.AfterOverloadedOperator &&
3549
44
             AfterRequiresInClause == Other.AfterRequiresInClause &&
3550
44
             AfterRequiresInExpression == Other.AfterRequiresInExpression &&
3551
44
             BeforeNonEmptyParentheses == Other.BeforeNonEmptyParentheses;
3552
44
    }
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
72
  bool operator==(const FormatStyle &R) const {
3850
72
    return AccessModifierOffset == R.AccessModifierOffset &&
3851
72
           
AlignAfterOpenBracket == R.AlignAfterOpenBracket60
&&
3852
72
           
AlignArrayOfStructures == R.AlignArrayOfStructures60
&&
3853
72
           
AlignConsecutiveAssignments == R.AlignConsecutiveAssignments60
&&
3854
72
           
AlignConsecutiveBitFields == R.AlignConsecutiveBitFields60
&&
3855
72
           
AlignConsecutiveDeclarations == R.AlignConsecutiveDeclarations60
&&
3856
72
           
AlignConsecutiveMacros == R.AlignConsecutiveMacros60
&&
3857
72
           
AlignEscapedNewlines == R.AlignEscapedNewlines60
&&
3858
72
           
AlignOperands == R.AlignOperands60
&&
3859
72
           
AlignTrailingComments == R.AlignTrailingComments60
&&
3860
72
           
AllowAllArgumentsOnNextLine == R.AllowAllArgumentsOnNextLine60
&&
3861
72
           AllowAllParametersOfDeclarationOnNextLine ==
3862
60
               R.AllowAllParametersOfDeclarationOnNextLine &&
3863
72
           
AllowShortEnumsOnASingleLine == R.AllowShortEnumsOnASingleLine56
&&
3864
72
           
AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine52
&&
3865
72
           AllowShortCaseLabelsOnASingleLine ==
3866
52
               R.AllowShortCaseLabelsOnASingleLine &&
3867
72
           AllowShortFunctionsOnASingleLine ==
3868
52
               R.AllowShortFunctionsOnASingleLine &&
3869
72
           AllowShortIfStatementsOnASingleLine ==
3870
52
               R.AllowShortIfStatementsOnASingleLine &&
3871
72
           
AllowShortLambdasOnASingleLine == R.AllowShortLambdasOnASingleLine52
&&
3872
72
           
AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine52
&&
3873
72
           
AlwaysBreakAfterReturnType == R.AlwaysBreakAfterReturnType52
&&
3874
72
           AlwaysBreakBeforeMultilineStrings ==
3875
48
               R.AlwaysBreakBeforeMultilineStrings &&
3876
72
           AlwaysBreakTemplateDeclarations ==
3877
48
               R.AlwaysBreakTemplateDeclarations &&
3878
72
           
AttributeMacros == R.AttributeMacros48
&&
3879
72
           
BinPackArguments == R.BinPackArguments48
&&
3880
72
           
BinPackParameters == R.BinPackParameters48
&&
3881
72
           
BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators48
&&
3882
72
           
BreakBeforeBraces == R.BreakBeforeBraces48
&&
3883
72
           
BreakBeforeConceptDeclarations == R.BreakBeforeConceptDeclarations48
&&
3884
72
           
BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators48
&&
3885
72
           
BreakConstructorInitializers == R.BreakConstructorInitializers48
&&
3886
72
           
CompactNamespaces == R.CompactNamespaces48
&&
3887
72
           
BreakAfterJavaFieldAnnotations == R.BreakAfterJavaFieldAnnotations48
&&
3888
72
           
BreakStringLiterals == R.BreakStringLiterals48
&&
3889
72
           
ColumnLimit == R.ColumnLimit48
&&
CommentPragmas == R.CommentPragmas48
&&
3890
72
           
BreakInheritanceList == R.BreakInheritanceList48
&&
3891
72
           ConstructorInitializerIndentWidth ==
3892
48
               R.ConstructorInitializerIndentWidth &&
3893
72
           
ContinuationIndentWidth == R.ContinuationIndentWidth48
&&
3894
72
           
Cpp11BracedListStyle == R.Cpp11BracedListStyle48
&&
3895
72
           
DeriveLineEnding == R.DeriveLineEnding48
&&
3896
72
           
DerivePointerAlignment == R.DerivePointerAlignment48
&&
3897
72
           
DisableFormat == R.DisableFormat48
&&
3898
72
           
EmptyLineAfterAccessModifier == R.EmptyLineAfterAccessModifier46
&&
3899
72
           
EmptyLineBeforeAccessModifier == R.EmptyLineBeforeAccessModifier46
&&
3900
72
           ExperimentalAutoDetectBinPacking ==
3901
46
               R.ExperimentalAutoDetectBinPacking &&
3902
72
           
PackConstructorInitializers == R.PackConstructorInitializers46
&&
3903
72
           
FixNamespaceComments == R.FixNamespaceComments46
&&
3904
72
           
ForEachMacros == R.ForEachMacros46
&&
3905
72
           
IncludeStyle.IncludeBlocks == R.IncludeStyle.IncludeBlocks44
&&
3906
72
           
IncludeStyle.IncludeCategories == R.IncludeStyle.IncludeCategories44
&&
3907
72
           IncludeStyle.IncludeIsMainRegex ==
3908
44
               R.IncludeStyle.IncludeIsMainRegex &&
3909
72
           IncludeStyle.IncludeIsMainSourceRegex ==
3910
44
               R.IncludeStyle.IncludeIsMainSourceRegex &&
3911
72
           
IndentAccessModifiers == R.IndentAccessModifiers44
&&
3912
72
           
IndentCaseLabels == R.IndentCaseLabels44
&&
3913
72
           
IndentCaseBlocks == R.IndentCaseBlocks44
&&
3914
72
           
IndentGotoLabels == R.IndentGotoLabels44
&&
3915
72
           
IndentPPDirectives == R.IndentPPDirectives44
&&
3916
72
           
IndentExternBlock == R.IndentExternBlock44
&&
3917
72
           
IndentRequiresClause == R.IndentRequiresClause44
&&
3918
72
           
IndentWidth == R.IndentWidth44
&&
Language == R.Language44
&&
3919
72
           
IndentWrappedFunctionNames == R.IndentWrappedFunctionNames44
&&
3920
72
           
JavaImportGroups == R.JavaImportGroups44
&&
3921
72
           
JavaScriptQuotes == R.JavaScriptQuotes44
&&
3922
72
           
JavaScriptWrapImports == R.JavaScriptWrapImports44
&&
3923
72
           KeepEmptyLinesAtTheStartOfBlocks ==
3924
44
               R.KeepEmptyLinesAtTheStartOfBlocks &&
3925
72
           
LambdaBodyIndentation == R.LambdaBodyIndentation44
&&
3926
72
           
MacroBlockBegin == R.MacroBlockBegin44
&&
3927
72
           
MacroBlockEnd == R.MacroBlockEnd44
&&
3928
72
           
MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep44
&&
3929
72
           
NamespaceIndentation == R.NamespaceIndentation44
&&
3930
72
           
NamespaceMacros == R.NamespaceMacros44
&&
3931
72
           
ObjCBinPackProtocolList == R.ObjCBinPackProtocolList44
&&
3932
72
           
ObjCBlockIndentWidth == R.ObjCBlockIndentWidth44
&&
3933
72
           ObjCBreakBeforeNestedBlockParam ==
3934
44
               R.ObjCBreakBeforeNestedBlockParam &&
3935
72
           
ObjCSpaceAfterProperty == R.ObjCSpaceAfterProperty44
&&
3936
72
           
ObjCSpaceBeforeProtocolList == R.ObjCSpaceBeforeProtocolList44
&&
3937
72
           
PenaltyBreakAssignment == R.PenaltyBreakAssignment44
&&
3938
72
           PenaltyBreakBeforeFirstCallParameter ==
3939
44
               R.PenaltyBreakBeforeFirstCallParameter &&
3940
72
           
PenaltyBreakComment == R.PenaltyBreakComment44
&&
3941
72
           
PenaltyBreakFirstLessLess == R.PenaltyBreakFirstLessLess44
&&
3942
72
           
PenaltyBreakOpenParenthesis == R.PenaltyBreakOpenParenthesis44
&&
3943
72
           
PenaltyBreakString == R.PenaltyBreakString44
&&
3944
72
           
PenaltyExcessCharacter == R.PenaltyExcessCharacter44
&&
3945
72
           
PenaltyReturnTypeOnItsOwnLine == R.PenaltyReturnTypeOnItsOwnLine44
&&
3946
72
           PenaltyBreakTemplateDeclaration ==
3947
44
               R.PenaltyBreakTemplateDeclaration &&
3948
72
           
PointerAlignment == R.PointerAlignment44
&&
3949
72
           
QualifierAlignment == R.QualifierAlignment44
&&
3950
72
           
QualifierOrder == R.QualifierOrder44
&&
3951
72
           
RawStringFormats == R.RawStringFormats44
&&
3952
72
           
ReferenceAlignment == R.ReferenceAlignment44
&&
3953
72
           
RemoveBracesLLVM == R.RemoveBracesLLVM44
&&
3954
72
           
RequiresClausePosition == R.RequiresClausePosition44
&&
3955
72
           
SeparateDefinitionBlocks == R.SeparateDefinitionBlocks44
&&
3956
72
           
ShortNamespaceLines == R.ShortNamespaceLines44
&&
3957
72
           
SortIncludes == R.SortIncludes44
&&
3958
72
           
SortJavaStaticImport == R.SortJavaStaticImport44
&&
3959
72
           
SpaceAfterCStyleCast == R.SpaceAfterCStyleCast44
&&
3960
72
           
SpaceAfterLogicalNot == R.SpaceAfterLogicalNot44
&&
3961
72
           
SpaceAfterTemplateKeyword == R.SpaceAfterTemplateKeyword44
&&
3962
72
           
SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators44
&&
3963
72
           
SpaceBeforeCaseColon == R.SpaceBeforeCaseColon44
&&
3964
72
           
SpaceBeforeCpp11BracedList == R.SpaceBeforeCpp11BracedList44
&&
3965
72
           SpaceBeforeCtorInitializerColon ==
3966
44
               R.SpaceBeforeCtorInitializerColon &&
3967
72
           
SpaceBeforeInheritanceColon == R.SpaceBeforeInheritanceColon44
&&
3968
72
           
SpaceBeforeParens == R.SpaceBeforeParens44
&&
3969
72
           
SpaceBeforeParensOptions == R.SpaceBeforeParensOptions44
&&
3970
72
           
SpaceAroundPointerQualifiers == R.SpaceAroundPointerQualifiers44
&&
3971
72
           SpaceBeforeRangeBasedForLoopColon ==
3972
44
               R.SpaceBeforeRangeBasedForLoopColon &&
3973
72
           
SpaceInEmptyBlock == R.SpaceInEmptyBlock44
&&
3974
72
           
SpaceInEmptyParentheses == R.SpaceInEmptyParentheses44
&&
3975
72
           
SpacesBeforeTrailingComments == R.SpacesBeforeTrailingComments44
&&
3976
72
           
SpacesInAngles == R.SpacesInAngles44
&&
3977
72
           
SpacesInConditionalStatement == R.SpacesInConditionalStatement44
&&
3978
72
           
SpacesInContainerLiterals == R.SpacesInContainerLiterals44
&&
3979
72
           
SpacesInCStyleCastParentheses == R.SpacesInCStyleCastParentheses44
&&
3980
72
           SpacesInLineCommentPrefix.Minimum ==
3981
44
               R.SpacesInLineCommentPrefix.Minimum &&
3982
72
           SpacesInLineCommentPrefix.Maximum ==
3983
44
               R.SpacesInLineCommentPrefix.Maximum &&
3984
72
           
SpacesInParentheses == R.SpacesInParentheses44
&&
3985
72
           
SpacesInSquareBrackets == R.SpacesInSquareBrackets44
&&
3986
72
           
SpaceBeforeSquareBrackets == R.SpaceBeforeSquareBrackets44
&&
3987
72
           
BitFieldColonSpacing == R.BitFieldColonSpacing44
&&
3988
72
           
Standard == R.Standard44
&&
3989
72
           
StatementAttributeLikeMacros == R.StatementAttributeLikeMacros44
&&
3990
72
           
StatementMacros == R.StatementMacros44
&&
TabWidth == R.TabWidth44
&&
3991
72
           
UseTab == R.UseTab44
&&
UseCRLF == R.UseCRLF44
&&
3992
72
           
TypenameMacros == R.TypenameMacros44
;
3993
72
  }
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
0
inline StringRef getLanguageName(FormatStyle::LanguageKind Language) {
4274
0
  switch (Language) {
4275
0
  case FormatStyle::LK_Cpp:
4276
0
    return "C++";
4277
0
  case FormatStyle::LK_CSharp:
4278
0
    return "CSharp";
4279
0
  case FormatStyle::LK_ObjC:
4280
0
    return "Objective-C";
4281
0
  case FormatStyle::LK_Java:
4282
0
    return "Java";
4283
0
  case FormatStyle::LK_JavaScript:
4284
0
    return "JavaScript";
4285
0
  case FormatStyle::LK_Json:
4286
0
    return "Json";
4287
0
  case FormatStyle::LK_Proto:
4288
0
    return "Proto";
4289
0
  case FormatStyle::LK_TableGen:
4290
0
    return "TableGen";
4291
0
  case FormatStyle::LK_TextProto:
4292
0
    return "TextProto";
4293
0
  case FormatStyle::LK_Verilog:
4294
0
    return "Verilog";
4295
0
  default:
4296
0
    return "Unknown";
4297
0
  }
4298
0
}
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