Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

 

 

 

namespace llvm {

namespace vfs {

class FileSystem;

} // namespace llvm

 

namespace clang {

namespace format {

 

enum class ParseError {

  Success = 0,

  Error,

  Unsuitable,

  BinPackTrailingCommaConflict,

  InvalidQualifierSpecified,

  DuplicateQualifierSpecified,

  MissingQualifierType,

  MissingQualifierOrder

class ParseErrorCategory final : public std::error_category {

  const char *name() const noexcept override;

  std::string message(int EV) const override;

const std::error_category &getParseCategory();

std::error_code make_error_code(ParseError e);

 

struct FormatStyle {

  // If the BasedOn: was InheritParentConfig and this style needs the file from

  // the parent directories. It is not part of the actual style for formatting.

  // Thus the // instead of ///.

  bool InheritsParentConfig;

 

  /// The extra indent or outdent of access modifiers, e.g. ``public:``.

  /// \version 3.3

  int AccessModifierOffset;

 

  /// Different styles for aligning after open brackets.

  enum BracketAlignmentStyle : int8_t {

    /// Align parameters on the open bracket, e.g.:

    /// \code

    ///   someLongFunction(argument1,

    ///                    argument2);

    /// \endcode

    BAS_Align,

    /// Don't align, instead use ``ContinuationIndentWidth``, e.g.:

    /// \code

    ///   someLongFunction(argument1,

    ///       argument2);

    /// \endcode

    BAS_DontAlign,

    /// Always break after an open bracket, if the parameters don't fit

    /// on a single line, e.g.:

    /// \code

    ///   someLongFunction(

    ///       argument1, argument2);

    /// \endcode

    BAS_AlwaysBreak,

    /// Always break after an open bracket, if the parameters don't fit

    /// on a single line. Closing brackets will be placed on a new line.

    /// E.g.:

    /// \code

    ///   someLongFunction(

    ///       argument1, argument2

    ///   )

    /// \endcode

    ///

    /// \warning

    ///  Note: This currently only applies to parentheses.

    /// \endwarning

    BAS_BlockIndent,

  };

 

  /// If ``true``, horizontally aligns arguments after an open bracket.

  ///

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

  /// brackets.

  /// \version 3.8

  BracketAlignmentStyle AlignAfterOpenBracket;

 

  /// Different style for aligning array initializers.

  enum ArrayInitializerAlignmentStyle : int8_t {

    /// Align array column and left justify the columns e.g.:

    /// \code

    ///   struct test demo[] =

    ///   {

    ///       {56, 23,    "hello"},

    ///       {-1, 93463, "world"},

    ///       {7,  5,     "!!"   }

    ///   };

    /// \endcode

    AIAS_Left,

    /// Align array column and right justify the columns e.g.:

    /// \code

    ///   struct test demo[] =

    ///   {

    ///       {56,    23, "hello"},

    ///       {-1, 93463, "world"},

    ///       { 7,     5,    "!!"}

    ///   };

    /// \endcode

    AIAS_Right,

    /// Don't align array initializer columns.

    AIAS_None

  };

  /// if not ``None``, when using initialization for an array of structs

  /// aligns the fields into columns.

  ///

  /// NOTE: As of clang-format 15 this option only applied to arrays with equal

  /// number of columns per row.

  ///

  /// \version 13

  ArrayInitializerAlignmentStyle AlignArrayOfStructures;

 

  /// Alignment options.

  ///

  /// They can also be read as a whole for compatibility. The choices are:

  /// - None

  /// - Consecutive

  /// - AcrossEmptyLines

  /// - AcrossComments

  /// - AcrossEmptyLinesAndComments

  ///

  /// For example, to align across empty lines and not across comments, either

  /// of these work.

  /// \code

  ///   AlignConsecutiveMacros: AcrossEmptyLines

  ///

  ///   AlignConsecutiveMacros:

  ///     Enabled: true

  ///     AcrossEmptyLines: true

  ///     AcrossComments: false

  /// \endcode

  struct AlignConsecutiveStyle {

    /// Whether aligning is enabled.

    /// \code

    ///   #define SHORT_NAME       42

    ///   #define LONGER_NAME      0x007f

    ///   #define EVEN_LONGER_NAME (2)

    ///   #define foo(x)           (x * x)

    ///   #define bar(y, z)        (y + z)

    ///

    ///   int a            = 1;

    ///   int somelongname = 2;

    ///   double c         = 3;

    ///

    ///   int aaaa : 1;

    ///   int b    : 12;

    ///   int ccc  : 8;

    ///

    ///   int         aaaa = 12;

    ///   float       b = 23;

    ///   std::string ccc;

    /// \endcode

    bool Enabled;

    /// Whether to align across empty lines.

    /// \code

    ///   true:

    ///   int a            = 1;

    ///   int somelongname = 2;

    ///   double c         = 3;

    ///

    ///   int d            = 3;

    ///

    ///   false:

    ///   int a            = 1;

    ///   int somelongname = 2;

    ///   double c         = 3;

    ///

    ///   int d = 3;

    /// \endcode

    bool AcrossEmptyLines;

    /// Whether to align across comments.

    /// \code

    ///   true:

    ///   int d    = 3;

    ///   /* A comment. */

    ///   double e = 4;

    ///

    ///   false:

    ///   int d = 3;

    ///   /* A comment. */

    ///   double e = 4;

    /// \endcode

    bool AcrossComments;

    /// Only for ``AlignConsecutiveAssignments``.  Whether compound assignments

    /// like ``+=`` are aligned along with ``=``.

    /// \code

    ///   true:

    ///   a   &= 2;

    ///   bbb  = 2;

    ///

    ///   false:

    ///   a &= 2;

    ///   bbb = 2;

    /// \endcode

    bool AlignCompound;

    /// Only for ``AlignConsecutiveAssignments``.  Whether short assignment

    /// operators are left-padded to the same length as long ones in order to

    /// put all assignment operators to the right of the left hand side.

    /// \code

    ///   true:

    ///   a   >>= 2;

    ///   bbb   = 2;

    ///

    ///   a     = 2;

    ///   bbb >>= 2;

    ///

    ///   false:

    ///   a >>= 2;

    ///   bbb = 2;

    ///

    ///   a     = 2;

    ///   bbb >>= 2;

    /// \endcode

    bool PadOperators;

    bool operator==(const AlignConsecutiveStyle &R) const {

      return Enabled == R.Enabled && AcrossEmptyLines == R.AcrossEmptyLines &&

             AcrossComments == R.AcrossComments &&

             AlignCompound == R.AlignCompound && PadOperators == R.PadOperators;

    }

    bool operator!=(const AlignConsecutiveStyle &R) const {

      return !(*this == R);

    }

  };

 

  /// Style of aligning consecutive macro definitions.

  ///

  /// ``Consecutive`` will result in formattings like:

  /// \code

  ///   #define SHORT_NAME       42

  ///   #define LONGER_NAME      0x007f

  ///   #define EVEN_LONGER_NAME (2)

  ///   #define foo(x)           (x * x)

  ///   #define bar(y, z)        (y + z)

  /// \endcode

  /// \version 9

  AlignConsecutiveStyle AlignConsecutiveMacros;

  /// Style of aligning consecutive assignments.

  ///

  /// ``Consecutive`` will result in formattings like:

  /// \code

  ///   int a            = 1;

  ///   int somelongname = 2;

  ///   double c         = 3;

  /// \endcode

  /// \version 3.8

  AlignConsecutiveStyle AlignConsecutiveAssignments;

  /// Style of aligning consecutive bit fields.

  ///

  /// ``Consecutive`` will align the bitfield separators of consecutive lines.

  /// This will result in formattings like:

  /// \code

  ///   int aaaa : 1;

  ///   int b    : 12;

  ///   int ccc  : 8;

  /// \endcode

  /// \version 11

  AlignConsecutiveStyle AlignConsecutiveBitFields;

  /// Style of aligning consecutive declarations.

  ///

  /// ``Consecutive`` will align the declaration names of consecutive lines.

  /// This will result in formattings like:

  /// \code

  ///   int         aaaa = 12;

  ///   float       b = 23;

  ///   std::string ccc;

  /// \endcode

  /// \version 3.8

  AlignConsecutiveStyle AlignConsecutiveDeclarations;

 

  /// Different styles for aligning escaped newlines.

  enum EscapedNewlineAlignmentStyle : int8_t {

    /// Don't align escaped newlines.

    /// \code

    ///   #define A \

    /// \endcode

    ENAS_DontAlign,

    /// Align escaped newlines as far left as possible.

    /// \code

    ///   true:

    ///   #define A   \

    ///

    ///   false:

    /// \endcode

    ENAS_Left,

    /// Align escaped newlines in the right-most column.

    /// \code

    ///   #define A                                                                      \

    /// \endcode

    ENAS_Right,

  };

 

  /// Options for aligning backslashes in escaped newlines.

  /// \version 5

  EscapedNewlineAlignmentStyle AlignEscapedNewlines;

 

  /// Different styles for aligning operands.

  enum OperandAlignmentStyle : int8_t {

    /// Do not align operands of binary and ternary expressions.

    /// The wrapped lines are indented ``ContinuationIndentWidth`` spaces from

    /// the start of the line.

    OAS_DontAlign,

    /// Horizontally align operands of binary and ternary expressions.

    ///

    /// Specifically, this aligns operands of a single expression that needs

    /// to be split over multiple lines, e.g.:

    /// \code

    ///   int aaa = bbbbbbbbbbbbbbb +

    ///             ccccccccccccccc;

    /// \endcode

    ///

    /// When ``BreakBeforeBinaryOperators`` is set, the wrapped operator is

    /// aligned with the operand on the first line.

    /// \code

    ///   int aaa = bbbbbbbbbbbbbbb

    ///             + ccccccccccccccc;

    /// \endcode

    OAS_Align,

    /// Horizontally align operands of binary and ternary expressions.

    ///

    /// This is similar to ``AO_Align``, except when

    /// ``BreakBeforeBinaryOperators`` is set, the operator is un-indented so

    /// that the wrapped operand is aligned with the operand on the first line.

    /// \code

    ///   int aaa = bbbbbbbbbbbbbbb

    ///           + ccccccccccccccc;

    /// \endcode

    OAS_AlignAfterOperator,

  };

 

  /// If ``true``, horizontally align operands of binary and ternary

  /// expressions.

  /// \version 3.5

  OperandAlignmentStyle AlignOperands;

 

  /// Enums for AlignTrailingComments

  enum TrailingCommentsAlignmentKinds : int8_t {

    /// Leave trailing comments as they are.

    /// \code

    ///   int a;    // comment

    ///   int ab;       // comment

    ///

    ///   int abc;  // comment

    ///   int abcd;     // comment

    /// \endcode

    TCAS_Leave,

    /// Align trailing comments.

    /// \code

    ///   int a;  // comment

    ///   int ab; // comment

    ///

    ///   int abc;  // comment

    ///   int abcd; // comment

    /// \endcode

    TCAS_Always,

    /// Don't align trailing comments but other formatter applies.

    /// \code

    ///   int a; // comment

    ///   int ab; // comment

    ///

    ///   int abc; // comment

    ///   int abcd; // comment

    /// \endcode

    TCAS_Never,

  };

 

  /// Alignment options

  struct TrailingCommentsAlignmentStyle {

    /// Specifies the way to align trailing comments.

    TrailingCommentsAlignmentKinds Kind;

    /// How many empty lines to apply alignment.

    /// When both ``MaxEmptyLinesToKeep`` and ``OverEmptyLines`` are set to 2,

    /// it formats like below.

    /// \code

    ///   int a;      // all these

    ///

    ///   int ab;     // comments are

    ///

    ///

    ///   int abcdef; // aligned

    /// \endcode

    ///

    /// When ``MaxEmptyLinesToKeep`` is set to 2 and ``OverEmptyLines`` is set

    /// to 1, it formats like below.

    /// \code

    ///   int a;  // these are

    ///

    ///   int ab; // aligned

    ///

    ///

    ///   int abcdef; // but this isn't

    /// \endcode

    unsigned OverEmptyLines;

 

    bool operator==(const TrailingCommentsAlignmentStyle &R) const {

      return Kind == R.Kind && OverEmptyLines == R.OverEmptyLines;

    }

    bool operator!=(const TrailingCommentsAlignmentStyle &R) const {

      return !(*this == R);

    }

  };

 

  /// Control of trailing comments.

  ///

  /// NOTE: As of clang-format 16 this option is not a bool but can be set

  /// to the options. Conventional bool options still can be parsed as before.

  ///

  /// \code{.yaml}

  ///   # Example of usage:

  ///   AlignTrailingComments:

  ///     Kind: Always

  ///     OverEmptyLines: 2

  /// \endcode

  /// \version 3.7

  TrailingCommentsAlignmentStyle AlignTrailingComments;

 

  /// \brief If a function call or braced initializer list doesn't fit on a

  /// line, allow putting all arguments onto the next line, even if

  /// ``BinPackArguments`` is ``false``.

  /// \code

  ///   true:

  ///   callFunction(

  ///       a, b, c, d);

  ///

  ///   false:

  ///   callFunction(a,

  ///                b,

  ///                c,

  ///                d);

  /// \endcode

  /// \version 9

  bool AllowAllArgumentsOnNextLine;

 

  /// This option is **deprecated**. See ``NextLine`` of

  /// ``PackConstructorInitializers``.

  /// \version 9

  // bool AllowAllConstructorInitializersOnNextLine;

 

  /// If the function declaration doesn't fit on a line,

  /// allow putting all parameters of a function declaration onto

  /// the next line even if ``BinPackParameters`` is ``false``.

  /// \code

  ///   true:

  ///   void myFunction(

  ///       int a, int b, int c, int d, int e);

  ///

  ///   false:

  ///   void myFunction(int a,

  ///                   int b,

  ///                   int c,

  ///                   int d,

  ///                   int e);

  /// \endcode

  /// \version 3.3

  bool AllowAllParametersOfDeclarationOnNextLine;

 

  /// Different styles for merging short blocks containing at most one

  /// statement.

  enum ShortBlockStyle : int8_t {

    /// Never merge blocks into a single line.

    /// \code

    ///   while (true) {

    ///   }

    ///   while (true) {

    ///     continue;

    ///   }

    /// \endcode

    SBS_Never,

    /// Only merge empty blocks.

    /// \code

    ///   while (true) {}

    ///   while (true) {

    ///     continue;

    ///   }

    /// \endcode

    SBS_Empty,

    /// Always merge short blocks into a single line.

    /// \code

    ///   while (true) {}

    ///   while (true) { continue; }

    /// \endcode

    SBS_Always,

  };

 

  /// Dependent on the value, ``while (true) { continue; }`` can be put on a

  /// single line.

  /// \version 3.5

  ShortBlockStyle AllowShortBlocksOnASingleLine;

 

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

  /// \code

  ///   true:                                   false:

  ///   switch (a) {                    vs.     switch (a) {

  ///   case 1: x = 1; break;                   case 1:

  ///   case 2: return;                           x = 1;

  ///   }                                         break;

  ///                                           case 2:

  ///                                             return;

  ///                                           }

  /// \endcode

  /// \version 3.6

  bool AllowShortCaseLabelsOnASingleLine;

 

  /// Allow short enums on a single line.

  /// \code

  ///   true:

  ///   enum { A, B } myEnum;

  ///

  ///   false:

  ///   enum {

  ///     A,

  ///     B

  ///   } myEnum;

  /// \endcode

  /// \version 11

  bool AllowShortEnumsOnASingleLine;

 

  /// Different styles for merging short functions containing at most one

  /// statement.

  enum ShortFunctionStyle : int8_t {

    /// Never merge functions into a single line.

    SFS_None,

    /// Only merge functions defined inside a class. Same as "inline",

    /// except it does not implies "empty": i.e. top level empty functions

    /// are not merged either.

    /// \code

    ///   class Foo {

    ///     void f() { foo(); }

    ///   };

    ///   void f() {

    ///     foo();

    ///   }

    ///   void f() {

    ///   }

    /// \endcode

    SFS_InlineOnly,

    /// Only merge empty functions.

    /// \code

    ///   void f() {}

    ///   void f2() {

    ///     bar2();

    ///   }

    /// \endcode

    SFS_Empty,

    /// Only merge functions defined inside a class. Implies "empty".

    /// \code

    ///   class Foo {

    ///     void f() { foo(); }

    ///   };

    ///   void f() {

    ///     foo();

    ///   }

    ///   void f() {}

    /// \endcode

    SFS_Inline,

    /// Merge all functions fitting on a single line.

    /// \code

    ///   class Foo {

    ///     void f() { foo(); }

    ///   };

    ///   void f() { bar(); }

    /// \endcode

    SFS_All,

  };

 

  /// Dependent on the value, ``int f() { return 0; }`` can be put on a

  /// single line.

  /// \version 3.5

  ShortFunctionStyle AllowShortFunctionsOnASingleLine;

 

  /// Different styles for handling short if statements.

  enum ShortIfStyle : int8_t {

    /// Never put short ifs on the same line.

    /// \code

    ///   if (a)

    ///     return;

    ///

    ///   if (b)

    ///     return;

    ///   else

    ///     return;

    ///

    ///   if (c)

    ///     return;

    ///   else {

    ///     return;

    ///   }

    /// \endcode

    SIS_Never,

    /// Put short ifs on the same line only if there is no else statement.

    /// \code

    ///   if (a) return;

    ///

    ///   if (b)

    ///     return;

    ///   else

    ///     return;

    ///

    ///   if (c)

    ///     return;

    ///   else {

    ///     return;

    ///   }

    /// \endcode

    SIS_WithoutElse,

    /// Put short ifs, but not else ifs nor else statements, on the same line.

    /// \code

    ///   if (a) return;

    ///

    ///   if (b) return;

    ///   else if (b)

    ///     return;

    ///   else

    ///     return;

    ///

    ///   if (c) return;

    ///   else {

    ///     return;

    ///   }

    /// \endcode

    SIS_OnlyFirstIf,

    /// Always put short ifs, else ifs and else statements on the same

    /// line.

    /// \code

    ///   if (a) return;

    ///

    ///   if (b) return;

    ///   else return;

    ///

    ///   if (c) return;

    ///   else {

    ///     return;

    ///   }

    /// \endcode

    SIS_AllIfsAndElse,

  };

 

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

  /// \version 3.3

  ShortIfStyle AllowShortIfStatementsOnASingleLine;

 

  /// Different styles for merging short lambdas containing at most one

  /// statement.

  enum ShortLambdaStyle : int8_t {

    /// Never merge lambdas into a single line.

    SLS_None,

    /// Only merge empty lambdas.

    /// \code

    ///   auto lambda = [](int a) {};

    ///   auto lambda2 = [](int a) {

    ///       return a;

    ///   };

    /// \endcode

    SLS_Empty,

    /// Merge lambda into a single line if the lambda is argument of a function.

    /// \code

    ///   auto lambda = [](int x, int y) {

    ///       return x < y;

    ///   };

    ///   sort(a.begin(), a.end(), [](int x, int y) { return x < y; });

    /// \endcode

    SLS_Inline,

    /// Merge all lambdas fitting on a single line.

    /// \code

    ///   auto lambda = [](int a) {};

    ///   auto lambda2 = [](int a) { return a; };

    /// \endcode

    SLS_All,

  };

 

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

  /// single line.

  /// \version 9

  ShortLambdaStyle AllowShortLambdasOnASingleLine;

 

  /// If ``true``, ``while (true) continue;`` can be put on a single

  /// line.

  /// \version 3.7

  bool AllowShortLoopsOnASingleLine;

 

  /// Different ways to break after the function definition return type.

  /// This option is **deprecated** and is retained for backwards compatibility.

  enum DefinitionReturnTypeBreakingStyle : int8_t {

    /// Break after return type automatically.

    /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.

    DRTBS_None,

    /// Always break after the return type.

    DRTBS_All,

    /// Always break after the return types of top-level functions.

    DRTBS_TopLevel,

  };

 

  /// Different ways to break after the function definition or

  /// declaration return type.

  enum ReturnTypeBreakingStyle : int8_t {

    /// Break after return type automatically.

    /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.

    /// \code

    ///   class A {

    ///     int f() { return 0; };

    ///   };

    ///   int f();

    ///   int f() { return 1; }

    /// \endcode

    RTBS_None,

    /// Always break after the return type.

    /// \code

    ///   class A {

    ///     int

    ///     f() {

    ///       return 0;

    ///     };

    ///   };

    ///   int

    ///   f();

    ///   int

    ///   f() {

    ///     return 1;

    ///   }

    /// \endcode

    RTBS_All,

    /// Always break after the return types of top-level functions.

    /// \code

    ///   class A {

    ///     int f() { return 0; };

    ///   };

    ///   int

    ///   f();

    ///   int

    ///   f() {

    ///     return 1;

    ///   }

    /// \endcode

    RTBS_TopLevel,

    /// Always break after the return type of function definitions.

    /// \code

    ///   class A {

    ///     int

    ///     f() {

    ///       return 0;

    ///     };

    ///   };

    ///   int f();

    ///   int

    ///   f() {

    ///     return 1;

    ///   }

    /// \endcode

    RTBS_AllDefinitions,

    /// Always break after the return type of top-level definitions.

    /// \code

    ///   class A {

    ///     int f() { return 0; };

    ///   };

    ///   int f();

    ///   int

    ///   f() {

    ///     return 1;

    ///   }

    /// \endcode

    RTBS_TopLevelDefinitions,

  };

 

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

  /// option is **deprecated** and is retained for backwards compatibility.

  /// \version 3.7

  DefinitionReturnTypeBreakingStyle AlwaysBreakAfterDefinitionReturnType;

 

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

  /// \version 3.8

  ReturnTypeBreakingStyle AlwaysBreakAfterReturnType;

 

  /// If ``true``, always break before multiline string literals.

  ///

  /// This flag is mean to make cases where there are multiple multiline strings

  /// in a file look more consistent. Thus, it will only take effect if wrapping

  /// the string at that point leads to it being indented

  /// ``ContinuationIndentWidth`` spaces from the start of the line.

  /// \code

  ///    true:                                  false:

  ///    aaaa =                         vs.     aaaa = "bbbb"

  ///        "bbbb"                                    "cccc";

  ///        "cccc";

  /// \endcode

  /// \version 3.4

  bool AlwaysBreakBeforeMultilineStrings;

 

  /// Different ways to break after the template declaration.

  enum BreakTemplateDeclarationsStyle : int8_t {

    /// Do not force break before declaration.

    /// ``PenaltyBreakTemplateDeclaration`` is taken into account.

    /// \code

    ///    template <typename T> T foo() {

    ///    }

    ///    template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa,

    ///                                int bbbbbbbbbbbbbbbbbbbbb) {

    ///    }

    /// \endcode

    BTDS_No,

    /// Force break after template declaration only when the following

    /// declaration spans multiple lines.

    /// \code

    ///    template <typename T> T foo() {

    ///    }

    ///    template <typename T>

    ///    T foo(int aaaaaaaaaaaaaaaaaaaaa,

    ///          int bbbbbbbbbbbbbbbbbbbbb) {

    ///    }

    /// \endcode

    BTDS_MultiLine,

    /// Always break after template declaration.

    /// \code

    ///    template <typename T>

    ///    T foo() {

    ///    }

    ///    template <typename T>

    ///    T foo(int aaaaaaaaaaaaaaaaaaaaa,

    ///          int bbbbbbbbbbbbbbbbbbbbb) {

    ///    }

    /// \endcode

    BTDS_Yes

  };

 

  /// The template declaration breaking style to use.

  /// \version 3.4

  BreakTemplateDeclarationsStyle AlwaysBreakTemplateDeclarations;

 

  /// A vector of strings that should be interpreted as attributes/qualifiers

  /// instead of identifiers. This can be useful for language extensions or

  /// static analyzer annotations.

  ///

  /// For example:

  /// \code

  ///   x = (char *__capability)&y;

  ///   int function(void) __ununsed;

  ///   void only_writes_to_buffer(char *__output buffer);

  /// \endcode

  ///

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

  /// \code{.yaml}

  ///   AttributeMacros: ['__capability', '__output', '__ununsed']

  /// \endcode

  ///

  /// \version 12

  std::vector<std::string> AttributeMacros;

 

  /// If ``false``, a function call's arguments will either be all on the

  /// same line or will have one line each.

  /// \code

  ///   true:

  ///   void f() {

  ///     f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,

  ///       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);

  ///   }

  ///

  ///   false:

  ///   void f() {

  ///     f(aaaaaaaaaaaaaaaaaaaa,

  ///       aaaaaaaaaaaaaaaaaaaa,

  ///       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);

  ///   }

  /// \endcode

  /// \version 3.7

  bool BinPackArguments;

 

  /// If ``false``, a function declaration's or function definition's

  /// parameters will either all be on the same line or will have one line each.

  /// \code

  ///   true:

  ///   void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,

  ///          int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}

  ///

  ///   false:

  ///   void f(int aaaaaaaaaaaaaaaaaaaa,

  ///          int aaaaaaaaaaaaaaaaaaaa,

  ///          int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}

  /// \endcode

  /// \version 3.7

  bool BinPackParameters;

 

  /// Styles for adding spacing around ``:`` in bitfield definitions.

  enum BitFieldColonSpacingStyle : int8_t {

    /// Add one space on each side of the ``:``

    /// \code

    ///   unsigned bf : 2;

    /// \endcode

    BFCS_Both,

    /// Add no space around the ``:`` (except when needed for

    /// ``AlignConsecutiveBitFields``).

    /// \code

    ///   unsigned bf:2;

    /// \endcode

    BFCS_None,

    /// Add space before the ``:`` only

    /// \code

    ///   unsigned bf :2;

    /// \endcode

    BFCS_Before,

    /// Add space after the ``:`` only (space may be added before if

    /// needed for ``AlignConsecutiveBitFields``).

    /// \code

    ///   unsigned bf: 2;

    /// \endcode

    BFCS_After

  };

  /// The BitFieldColonSpacingStyle to use for bitfields.

  /// \version 12

  BitFieldColonSpacingStyle BitFieldColonSpacing;

 

  /// Different ways to wrap braces after control statements.

  enum BraceWrappingAfterControlStatementStyle : int8_t {

    /// Never wrap braces after a control statement.

    /// \code

    ///   if (foo()) {

    ///   } else {

    ///   }

    ///   for (int i = 0; i < 10; ++i) {

    ///   }

    /// \endcode

    BWACS_Never,

    /// Only wrap braces after a multi-line control statement.

    /// \code

    ///   if (foo && bar &&

    ///       baz)

    ///   {

    ///     quux();

    ///   }

    ///   while (foo || bar) {

    ///   }

    /// \endcode

    BWACS_MultiLine,

    /// Always wrap braces after a control statement.

    /// \code

    ///   if (foo())

    ///   {

    ///   } else

    ///   {}

    ///   for (int i = 0; i < 10; ++i)

    ///   {}

    /// \endcode

    BWACS_Always

  };

 

  /// Precise control over the wrapping of braces.

  /// \code

  ///   # Should be declared this way:

  ///   BreakBeforeBraces: Custom

  ///   BraceWrapping:

  ///       AfterClass: true

  /// \endcode

  struct BraceWrappingFlags {

    /// Wrap case labels.

    /// \code

    ///   false:                                true:

    ///   switch (foo) {                vs.     switch (foo) {

    ///     case 1: {                             case 1:

    ///       bar();                              {

    ///       break;                                bar();

    ///     }                                       break;

    ///     default: {                            }

    ///       plop();                             default:

    ///     }                                     {

    ///   }                                         plop();

    ///                                           }

    ///                                         }

    /// \endcode

    bool AfterCaseLabel;

    /// Wrap class definitions.

    /// \code

    ///   true:

    ///   class foo

    ///   {};

    ///

    ///   false:

    ///   class foo {};

    /// \endcode

    bool AfterClass;

 

    /// Wrap control statements (``if``/``for``/``while``/``switch``/..).

    BraceWrappingAfterControlStatementStyle AfterControlStatement;

    /// Wrap enum definitions.

    /// \code

    ///   true:

    ///   enum X : int

    ///   {

    ///     B

    ///   };

    ///

    ///   false:

    ///   enum X : int { B };

    /// \endcode

    bool AfterEnum;

    /// Wrap function definitions.

    /// \code

    ///   true:

    ///   void foo()

    ///   {

    ///     bar();

    ///     bar2();

    ///   }

    ///

    ///   false:

    ///   void foo() {

    ///     bar();

    ///     bar2();

    ///   }

    /// \endcode

    bool AfterFunction;

    /// Wrap namespace definitions.

    /// \code

    ///   true:

    ///   namespace

    ///   {

    ///   int foo();

    ///   int bar();

    ///   }

    ///

    ///   false:

    ///   namespace {

    ///   int foo();

    ///   int bar();

    ///   }

    /// \endcode

    bool AfterNamespace;

    /// Wrap ObjC definitions (interfaces, implementations...).

    /// \note @autoreleasepool and @synchronized blocks are wrapped

    /// according to `AfterControlStatement` flag.

    bool AfterObjCDeclaration;

    /// Wrap struct definitions.

    /// \code

    ///   true:

    ///   struct foo

    ///   {

    ///     int x;

    ///   };

    ///

    ///   false:

    ///   struct foo {

    ///     int x;

    ///   };

    /// \endcode

    bool AfterStruct;

    /// Wrap union definitions.

    /// \code

    ///   true:

    ///   union foo

    ///   {

    ///     int x;

    ///   }

    ///

    ///   false:

    ///   union foo {

    ///     int x;

    ///   }

    /// \endcode

    bool AfterUnion;

    /// Wrap extern blocks.

    /// \code

    ///   true:

    ///   extern "C"

    ///   {

    ///     int foo();

    ///   }

    ///

    ///   false:

    ///   extern "C" {

    ///   int foo();

    ///   }

    /// \endcode

    bool AfterExternBlock; // Partially superseded by IndentExternBlock

    /// Wrap before ``catch``.

    /// \code

    ///   true:

    ///   try {

    ///     foo();

    ///   }

    ///   catch () {

    ///   }

    ///

    ///   false:

    ///   try {

    ///     foo();

    ///   } catch () {

    ///   }

    /// \endcode

    bool BeforeCatch;

    /// Wrap before ``else``.

    /// \code

    ///   true:

    ///   if (foo()) {

    ///   }

    ///   else {

    ///   }

    ///

    ///   false:

    ///   if (foo()) {

    ///   } else {

    ///   }

    /// \endcode

    bool BeforeElse;

    /// Wrap lambda block.

    /// \code

    ///   true:

    ///   connect(

    ///     []()

    ///     {

    ///       foo();

    ///       bar();

    ///     });

    ///

    ///   false:

    ///   connect([]() {

    ///     foo();

    ///     bar();

    ///   });

    /// \endcode

    bool BeforeLambdaBody;

    /// Wrap before ``while``.

    /// \code

    ///   true:

    ///   do {

    ///     foo();

    ///   }

    ///   while (1);

    ///

    ///   false:

    ///   do {

    ///     foo();

    ///   } while (1);

    /// \endcode

    bool BeforeWhile;

    /// Indent the wrapped braces themselves.

    bool IndentBraces;

    /// If ``false``, empty function body can be put on a single line.

    /// This option is used only if the opening brace of the function has

    /// already been wrapped, i.e. the `AfterFunction` brace wrapping mode is

    /// set, and the function could/should not be put on a single line (as per

    /// `AllowShortFunctionsOnASingleLine` and constructor formatting options).

    /// \code

    ///   false:          true:

    ///   int f()   vs.   int f()

    ///   {}              {

    ///                   }

    /// \endcode

    ///

    bool SplitEmptyFunction;

    /// If ``false``, empty record (e.g. class, struct or union) body

    /// can be put on a single line. This option is used only if the opening

    /// brace of the record has already been wrapped, i.e. the `AfterClass`

    /// (for classes) brace wrapping mode is set.

    /// \code

    ///   false:           true:

    ///   class Foo   vs.  class Foo

    ///   {}               {

    ///                    }

    /// \endcode

    ///

    bool SplitEmptyRecord;

    /// If ``false``, empty namespace body can be put on a single line.

    /// This option is used only if the opening brace of the namespace has

    /// already been wrapped, i.e. the `AfterNamespace` brace wrapping mode is

    /// set.

    /// \code

    ///   false:               true:

    ///   namespace Foo   vs.  namespace Foo

    ///   {}                   {

    ///                        }

    /// \endcode

    ///

    bool SplitEmptyNamespace;

  };

 

  /// Control of individual brace wrapping cases.

  ///

  /// If ``BreakBeforeBraces`` is set to ``BS_Custom``, use this to specify how

  /// each individual brace case should be handled. Otherwise, this is ignored.

  /// \code{.yaml}

  ///   # Example of usage:

  ///   BreakBeforeBraces: Custom

  ///   BraceWrapping:

  ///     AfterEnum: true

  ///     AfterStruct: false

  ///     SplitEmptyFunction: false

  /// \endcode

  /// \version 3.8

  BraceWrappingFlags BraceWrapping;

 

  /// Different ways to break after attributes.

  enum AttributeBreakingStyle : int8_t {

    /// Always break after attributes.

    /// \code

    ///   [[nodiscard]]

    ///   inline int f();

    ///   [[gnu::const]] [[nodiscard]]

    ///   int g();

    /// \endcode

    ABS_Always,

    /// Leave the line breaking after attributes as is.

    /// \code

    ///   [[nodiscard]] inline int f();

    ///   [[gnu::const]] [[nodiscard]]

    ///   int g();

    /// \endcode

    ABS_Leave,

    /// Never break after attributes.

    /// \code

    ///   [[nodiscard]] inline int f();

    ///   [[gnu::const]] [[nodiscard]] int g();

    /// \endcode

    ABS_Never,

  };

 

  /// Break after a group of C++11 attributes before a function

  /// declaration/definition name.

  /// \version 16

  AttributeBreakingStyle BreakAfterAttributes;

 

  /// If ``true``, clang-format will always break after a Json array `[`

  /// otherwise it will scan until the closing `]` to determine if it should add

  /// newlines between elements (prettier compatible).

  ///

  /// NOTE: This is currently only for formatting JSON.

  /// \code

  ///    true:                                  false:

  ///    [                          vs.      [1, 2, 3, 4]

  ///      1,

  ///      2,

  ///      3,

  ///      4

  ///    ]

  /// \endcode

  /// \version 16

  bool BreakArrays;

 

  /// The style of wrapping parameters on the same line (bin-packed) or

  /// on one line each.

  enum BinPackStyle : int8_t {

    /// Automatically determine parameter bin-packing behavior.

    BPS_Auto,

    /// Always bin-pack parameters.

    BPS_Always,

    /// Never bin-pack parameters.

    BPS_Never,

  };

 

  /// The style of breaking before or after binary operators.

  enum BinaryOperatorStyle : int8_t {

    /// Break after operators.

    /// \code

    ///    LooooooooooongType loooooooooooooooooooooongVariable =

    ///        someLooooooooooooooooongFunction();

    ///

    ///    bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +

    ///                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==

    ///                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&

    ///                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >

    ///                     ccccccccccccccccccccccccccccccccccccccccc;

    /// \endcode

    BOS_None,

    /// Break before operators that aren't assignments.

    /// \code

    ///    LooooooooooongType loooooooooooooooooooooongVariable =

    ///        someLooooooooooooooooongFunction();

    ///

    ///    bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

    ///                         + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

    ///                     == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

    ///                 && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

    ///                        > ccccccccccccccccccccccccccccccccccccccccc;

    /// \endcode

    BOS_NonAssignment,

    /// Break before operators.

    /// \code

    ///    LooooooooooongType loooooooooooooooooooooongVariable

    ///        = someLooooooooooooooooongFunction();

    ///

    ///    bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

    ///                         + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

    ///                     == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

    ///                 && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

    ///                        > ccccccccccccccccccccccccccccccccccccccccc;

    /// \endcode

    BOS_All,

  };

 

  /// The way to wrap binary operators.

  /// \version 3.6

  BinaryOperatorStyle BreakBeforeBinaryOperators;

 

  /// Different ways to attach braces to their surrounding context.

  enum BraceBreakingStyle : int8_t {

    /// Always attach braces to surrounding context.

    /// \code

    ///   namespace N {

    ///   enum E {

    ///     E1,

    ///     E2,

    ///   };

    ///

    ///   class C {

    ///   public:

    ///     C();

    ///   };

    ///

    ///   bool baz(int i) {

    ///     try {

    ///       do {

    ///         switch (i) {

    ///         case 1: {

    ///           foobar();

    ///           break;

    ///         }

    ///         default: {

    ///           break;

    ///         }

    ///         }

    ///       } while (--i);

    ///       return true;

    ///     } catch (...) {

    ///       handleError();

    ///       return false;

    ///     }

    ///   }

    ///

    ///   void foo(bool b) {

    ///     if (b) {

    ///       baz(2);

    ///     } else {

    ///       baz(5);

    ///     }

    ///   }

    ///

    ///   void bar() { foo(true); }

    ///   } // namespace N

    /// \endcode

    BS_Attach,

    /// Like ``Attach``, but break before braces on function, namespace and

    /// class definitions.

    /// \code

    ///   namespace N

    ///   {

    ///   enum E {

    ///     E1,

    ///     E2,

    ///   };

    ///

    ///   class C

    ///   {

    ///   public:

    ///     C();

    ///   };

    ///

    ///   bool baz(int i)

    ///   {

    ///     try {

    ///       do {

    ///         switch (i) {

    ///         case 1: {

    ///           foobar();

    ///           break;

    ///         }

    ///         default: {

    ///           break;

    ///         }

    ///         }

    ///       } while (--i);

    ///       return true;

    ///     } catch (...) {

    ///       handleError();

    ///       return false;

    ///     }

    ///   }

    ///

    ///   void foo(bool b)

    ///   {

    ///     if (b) {

    ///       baz(2);

    ///     } else {

    ///       baz(5);

    ///     }

    ///   }

    ///

    ///   void bar() { foo(true); }

    ///   } // namespace N

    /// \endcode

    BS_Linux,

    /// Like ``Attach``, but break before braces on enum, function, and record

    /// definitions.

    /// \code

    ///   namespace N {

    ///   enum E

    ///   {

    ///     E1,

    ///     E2,

    ///   };

    ///

    ///   class C

    ///   {

    ///   public:

    ///     C();

    ///   };

    ///

    ///   bool baz(int i)

    ///   {

    ///     try {

    ///       do {

    ///         switch (i) {

    ///         case 1: {

    ///           foobar();

    ///           break;

    ///         }

    ///         default: {

    ///           break;

    ///         }

    ///         }

    ///       } while (--i);

    ///       return true;

    ///     } catch (...) {

    ///       handleError();

    ///       return false;

    ///     }

    ///   }

    ///

    ///   void foo(bool b)

    ///   {

    ///     if (b) {

    ///       baz(2);

    ///     } else {

    ///       baz(5);

    ///     }

    ///   }

    ///

    ///   void bar() { foo(true); }

    ///   } // namespace N

    /// \endcode

    BS_Mozilla,

    /// Like ``Attach``, but break before function definitions, ``catch``, and

    /// ``else``.

    /// \code

    ///   namespace N {

    ///   enum E {

    ///     E1,

    ///     E2,

    ///   };

    ///

    ///   class C {

    ///   public:

    ///     C();

    ///   };

    ///

    ///   bool baz(int i)

    ///   {

    ///     try {

    ///       do {

    ///         switch (i) {

    ///         case 1: {

    ///           foobar();

    ///           break;

    ///         }

    ///         default: {

    ///           break;

    ///         }

    ///         }

    ///       } while (--i);

    ///       return true;

    ///     }

    ///     catch (...) {

    ///       handleError();

    ///       return false;

    ///     }

    ///   }

    ///

    ///   void foo(bool b)

    ///   {

    ///     if (b) {

    ///       baz(2);

    ///     }

    ///     else {

    ///       baz(5);

    ///     }

    ///   }

    ///

    ///   void bar() { foo(true); }

    ///   } // namespace N

    /// \endcode

    BS_Stroustrup,

    /// Always break before braces.

    /// \code

    ///   namespace N

    ///   {

    ///   enum E

    ///   {

    ///     E1,

    ///     E2,

    ///   };

    ///

    ///   class C

    ///   {

    ///   public:

    ///     C();

    ///   };

    ///

    ///   bool baz(int i)

    ///   {

    ///     try

    ///     {

    ///       do

    ///       {

    ///         switch (i)

    ///         {

    ///         case 1:

    ///         {

    ///           foobar();

    ///           break;

    ///         }

    ///         default:

    ///         {

    ///           break;

    ///         }

    ///         }

    ///       } while (--i);

    ///       return true;

    ///     }

    ///     catch (...)

    ///     {

    ///       handleError();

    ///       return false;

    ///     }

    ///   }

    ///

    ///   void foo(bool b)

    ///   {

    ///     if (b)

    ///     {

    ///       baz(2);

    ///     }

    ///     else

    ///     {

    ///       baz(5);

    ///     }

    ///   }

    ///

    ///   void bar() { foo(true); }

    ///   } // namespace N

    /// \endcode

    BS_Allman,

    /// Like ``Allman`` but always indent braces and line up code with braces.

    /// \code

    ///   namespace N

    ///     {

    ///   enum E

    ///     {

    ///     E1,

    ///     E2,

    ///     };

    ///

    ///   class C

    ///     {

    ///   public:

    ///     C();

    ///     };

    ///

    ///   bool baz(int i)

    ///     {

    ///     try

    ///       {

    ///       do

    ///         {

    ///         switch (i)

    ///           {

    ///           case 1:

    ///           {

    ///           foobar();

    ///           break;

    ///           }

    ///           default:

    ///           {

    ///           break;

    ///           }

    ///           }

    ///         } while (--i);

    ///       return true;

    ///       }

    ///     catch (...)

    ///       {

    ///       handleError();

    ///       return false;

    ///       }

    ///     }

    ///

    ///   void foo(bool b)

    ///     {

    ///     if (b)

    ///       {

    ///       baz(2);

    ///       }

    ///     else

    ///       {

    ///       baz(5);

    ///       }

    ///     }

    ///

    ///   void bar() { foo(true); }

    ///     } // namespace N

    /// \endcode

    BS_Whitesmiths,

    /// Always break before braces and add an extra level of indentation to

    /// braces of control statements, not to those of class, function

    /// or other definitions.

    /// \code

    ///   namespace N

    ///   {

    ///   enum E

    ///   {

    ///     E1,

    ///     E2,

    ///   };

    ///

    ///   class C

    ///   {

    ///   public:

    ///     C();

    ///   };

    ///

    ///   bool baz(int i)

    ///   {

    ///     try

    ///       {

    ///         do

    ///           {

    ///             switch (i)

    ///               {

    ///               case 1:

    ///                 {

    ///                   foobar();

    ///                   break;

    ///                 }

    ///               default:

    ///                 {

    ///                   break;

    ///                 }

    ///               }

    ///           }

    ///         while (--i);

    ///         return true;

    ///       }

    ///     catch (...)

    ///       {

    ///         handleError();

    ///         return false;

    ///       }

    ///   }

    ///

    ///   void foo(bool b)

    ///   {

    ///     if (b)

    ///       {

    ///         baz(2);

    ///       }

    ///     else

    ///       {

    ///         baz(5);

    ///       }

    ///   }

    ///

    ///   void bar() { foo(true); }

    ///   } // namespace N

    /// \endcode

    BS_GNU,

    /// Like ``Attach``, but break before functions.

    /// \code

    ///   namespace N {

    ///   enum E {

    ///     E1,

    ///     E2,

    ///   };

    ///

    ///   class C {

    ///   public:

    ///     C();

    ///   };

    ///

    ///   bool baz(int i)

    ///   {

    ///     try {

    ///       do {

    ///         switch (i) {

    ///         case 1: {

    ///           foobar();

    ///           break;

    ///         }

    ///         default: {

    ///           break;

    ///         }

    ///         }

    ///       } while (--i);

    ///       return true;

    ///     } catch (...) {

    ///       handleError();

    ///       return false;

    ///     }

    ///   }

    ///

    ///   void foo(bool b)

    ///   {

    ///     if (b) {

    ///       baz(2);

    ///     } else {

    ///       baz(5);

    ///     }

    ///   }

    ///

    ///   void bar() { foo(true); }

    ///   } // namespace N

    /// \endcode

    BS_WebKit,

    /// Configure each individual brace in `BraceWrapping`.

    BS_Custom

  };

 

  /// The brace breaking style to use.

  /// \version 3.7

  BraceBreakingStyle BreakBeforeBraces;

 

  /// Different ways to break before concept declarations.

  enum BreakBeforeConceptDeclarationsStyle : int8_t {

    /// Keep the template declaration line together with ``concept``.

    /// \code

    ///   template <typename T> concept C = ...;

    /// \endcode

    BBCDS_Never,

    /// Breaking between template declaration and ``concept`` is allowed. The

    /// actual behavior depends on the content and line breaking rules and

    /// penalities.

    BBCDS_Allowed,

    /// Always break before ``concept``, putting it in the line after the

    /// template declaration.

    /// \code

    ///   template <typename T>

    ///   concept C = ...;

    /// \endcode

    BBCDS_Always,

  };

 

  /// The concept declaration style to use.

  /// \version 12

  BreakBeforeConceptDeclarationsStyle BreakBeforeConceptDeclarations;

 

  /// Different ways to break ASM parameters.

  enum BreakBeforeInlineASMColonStyle : int8_t {

    /// No break before inline ASM colon.

    /// \code

    ///    asm volatile("string", : : val);

    /// \endcode

    BBIAS_Never,

    /// Break before inline ASM colon if the line length is longer than column

    /// limit.

    /// \code

    ///    asm volatile("string", : : val);

    ///    asm("cmoveq %1, %2, %[result]"

    ///        : [result] "=r"(result)

    ///        : "r"(test), "r"(new), "[result]"(old));

    /// \endcode

    BBIAS_OnlyMultiline,

    /// Always break before inline ASM colon.

    /// \code

    ///    asm volatile("string",

    ///                 :

    ///                 : val);

    /// \endcode

    BBIAS_Always,

  };

 

  /// The inline ASM colon style to use.

  /// \version 16

  BreakBeforeInlineASMColonStyle BreakBeforeInlineASMColon;

 

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

  /// \code

  ///    true:

  ///    veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription

  ///        ? firstValue

  ///        : SecondValueVeryVeryVeryVeryLong;

  ///

  ///    false:

  ///    veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?

  ///        firstValue :

  ///        SecondValueVeryVeryVeryVeryLong;

  /// \endcode

  /// \version 3.7

  bool BreakBeforeTernaryOperators;

 

  /// Different ways to break initializers.

  enum BreakConstructorInitializersStyle : int8_t {

    /// Break constructor initializers before the colon and after the commas.

    /// \code

    ///    Constructor()

    ///        : initializer1(),

    ///          initializer2()

    /// \endcode

    BCIS_BeforeColon,

    /// Break constructor initializers before the colon and commas, and align

    /// the commas with the colon.

    /// \code

    ///    Constructor()

    ///        : initializer1()

    ///        , initializer2()

    /// \endcode

    BCIS_BeforeComma,

    /// Break constructor initializers after the colon and commas.

    /// \code

    ///    Constructor() :

    ///        initializer1(),

    ///        initializer2()

    /// \endcode

    BCIS_AfterColon

  };

 

  /// The break constructor initializers style to use.

  /// \version 5

  BreakConstructorInitializersStyle BreakConstructorInitializers;

 

  /// Break after each annotation on a field in Java files.

  /// \code{.java}

  ///    true:                                  false:

  ///    @Partial                       vs.     @Partial @Mock DataLoad loader;

  ///    @Mock

  ///    DataLoad loader;

  /// \endcode

  /// \version 3.8

  bool BreakAfterJavaFieldAnnotations;

 

  /// Allow breaking string literals when formatting.

  /// \code

  ///    true:

  ///    const char* x = "veryVeryVeryVeryVeryVe"

  ///                    "ryVeryVeryVeryVeryVery"

  ///                    "VeryLongString";

  ///

  ///    false:

  ///    const char* x =

  ///      "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";

  /// \endcode

  /// \version 3.9

  bool BreakStringLiterals;

 

  /// The column limit.

  ///

  /// A column limit of ``0`` means that there is no column limit. In this case,

  /// clang-format will respect the input's line breaking decisions within

  /// statements unless they contradict other rules.

  /// \version 3.7

  unsigned ColumnLimit;

 

  /// A regular expression that describes comments with special meaning,

  /// which should not be split into lines or otherwise changed.

  /// \code

  ///    // CommentPragmas: '^ FOOBAR pragma:'

  ///    // Will leave the following line unaffected

  ///    #include <vector> // FOOBAR pragma: keep

  /// \endcode

  /// \version 3.7

  std::string CommentPragmas;

 

  /// Different ways to break inheritance list.

  enum BreakInheritanceListStyle : int8_t {

    /// Break inheritance list before the colon and after the commas.

    /// \code

    ///    class Foo

    ///        : Base1,

    ///          Base2

    ///    {};

    /// \endcode

    BILS_BeforeColon,

    /// Break inheritance list before the colon and commas, and align

    /// the commas with the colon.

    /// \code

    ///    class Foo

    ///        : Base1

    ///        , Base2

    ///    {};

    /// \endcode

    BILS_BeforeComma,

    /// Break inheritance list after the colon and commas.

    /// \code

    ///    class Foo :

    ///        Base1,

    ///        Base2

    ///    {};

    /// \endcode

    BILS_AfterColon,

    /// Break inheritance list only after the commas.

    /// \code

    ///    class Foo : Base1,

    ///                Base2

    ///    {};

    /// \endcode

    BILS_AfterComma,

  };

 

  /// The inheritance list style to use.

  /// \version 7

  BreakInheritanceListStyle BreakInheritanceList;

 

  /// If ``true``, consecutive namespace declarations will be on the same

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

  /// \code

  ///   true:

  ///   namespace Foo { namespace Bar {

  ///   }}

  ///

  ///   false:

  ///   namespace Foo {

  ///   namespace Bar {

  ///   }

  ///   }

  /// \endcode

  ///

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

  /// wrapped:

  /// \code

  ///   namespace Foo { namespace Bar {

  ///   namespace Extra {

  ///   }}}

  /// \endcode

  /// \version 5

  bool CompactNamespaces;

 

  /// This option is **deprecated**. See ``CurrentLine`` of

  /// ``PackConstructorInitializers``.

  /// \version 3.7

  // bool ConstructorInitializerAllOnOneLineOrOnePerLine;

 

  /// The number of characters to use for indentation of constructor

  /// initializer lists as well as inheritance lists.

  /// \version 3.7

  unsigned ConstructorInitializerIndentWidth;

 

  /// Indent width for line continuations.

  /// \code

  ///    ContinuationIndentWidth: 2

  ///

  ///    int i =         //  VeryVeryVeryVeryVeryLongComment

  ///      longFunction( // Again a long comment

  ///        arg);

  /// \endcode

  /// \version 3.7

  unsigned ContinuationIndentWidth;

 

  /// If ``true``, format braced lists as best suited for C++11 braced

  /// lists.

  ///

  /// Important differences:

  /// - No spaces inside the braced list.

  /// - No line break before the closing brace.

  /// - Indentation with the continuation indent, not with the block indent.

  ///

  /// Fundamentally, C++11 braced lists are formatted exactly like function

  /// calls would be formatted in their place. If the braced list follows a name

  /// (e.g. a type or variable name), clang-format formats as if the ``{}`` were

  /// the parentheses of a function call with that name. If there is no name,

  /// a zero-length name is assumed.

  /// \code

  ///    true:                                  false:

  ///    vector<int> x{1, 2, 3, 4};     vs.     vector<int> x{ 1, 2, 3, 4 };

  ///    vector<T> x{{}, {}, {}, {}};           vector<T> x{ {}, {}, {}, {} };

  ///    f(MyMap[{composite, key}]);            f(MyMap[{ composite, key }]);

  ///    new int[3]{1, 2, 3};                   new int[3]{ 1, 2, 3 };

  /// \endcode

  /// \version 3.4

  bool Cpp11BracedListStyle;

 

  /// This option is **deprecated**. See ``DeriveLF`` and ``DeriveCRLF`` of

  /// ``LineEnding``.

  /// \version 10

  // bool DeriveLineEnding;

 

  /// If ``true``, analyze the formatted file for the most common

  /// alignment of ``&`` and ``*``.

  /// Pointer and reference alignment styles are going to be updated according

  /// to the preferences found in the file.

  /// ``PointerAlignment`` is then used only as fallback.

  /// \version 3.7

  bool DerivePointerAlignment;

 

  /// Disables formatting completely.

  /// \version 3.7

  bool DisableFormat;

 

  /// Different styles for empty line after access modifiers.

  /// ``EmptyLineBeforeAccessModifier`` configuration handles the number of

  /// empty lines between two access modifiers.

  enum EmptyLineAfterAccessModifierStyle : int8_t {

    /// Remove all empty lines after access modifiers.

    /// \code

    ///   struct foo {

    ///   private:

    ///     int i;

    ///   protected:

    ///     int j;

    ///     /* comment */

    ///   public:

    ///     foo() {}

    ///   private:

    ///   protected:

    ///   };

    /// \endcode

    ELAAMS_Never,

    /// Keep existing empty lines after access modifiers.

    /// MaxEmptyLinesToKeep is applied instead.

    ELAAMS_Leave,

    /// Always add empty line after access modifiers if there are none.

    /// MaxEmptyLinesToKeep is applied also.

    /// \code

    ///   struct foo {

    ///   private:

    ///

    ///     int i;

    ///   protected:

    ///

    ///     int j;

    ///     /* comment */

    ///   public:

    ///

    ///     foo() {}

    ///   private:

    ///

    ///   protected:

    ///

    ///   };

    /// \endcode

    ELAAMS_Always,

  };

 

  /// Defines when to put an empty line after access modifiers.

  /// ``EmptyLineBeforeAccessModifier`` configuration handles the number of

  /// empty lines between two access modifiers.

  /// \version 13

  EmptyLineAfterAccessModifierStyle EmptyLineAfterAccessModifier;

 

  /// Different styles for empty line before access modifiers.

  enum EmptyLineBeforeAccessModifierStyle : int8_t {

    /// Remove all empty lines before access modifiers.

    /// \code

    ///   struct foo {

    ///   private:

    ///     int i;

    ///   protected:

    ///     int j;

    ///     /* comment */

    ///   public:

    ///     foo() {}

    ///   private:

    ///   protected:

    ///   };

    /// \endcode

    ELBAMS_Never,

    /// Keep existing empty lines before access modifiers.

    ELBAMS_Leave,

    /// Add empty line only when access modifier starts a new logical block.

    /// Logical block is a group of one or more member fields or functions.

    /// \code

    ///   struct foo {

    ///   private:

    ///     int i;

    ///

    ///   protected:

    ///     int j;

    ///     /* comment */

    ///   public:

    ///     foo() {}

    ///

    ///   private:

    ///   protected:

    ///   };

    /// \endcode

    ELBAMS_LogicalBlock,

    /// Always add empty line before access modifiers unless access modifier

    /// is at the start of struct or class definition.

    /// \code

    ///   struct foo {

    ///   private:

    ///     int i;

    ///

    ///   protected:

    ///     int j;

    ///     /* comment */

    ///

    ///   public:

    ///     foo() {}

    ///

    ///   private:

    ///

    ///   protected:

    ///   };

    /// \endcode

    ELBAMS_Always,

  };

 

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

  /// \version 12

  EmptyLineBeforeAccessModifierStyle EmptyLineBeforeAccessModifier;

 

  /// If ``true``, clang-format detects whether function calls and

  /// definitions are formatted with one parameter per line.

  ///

  /// Each call can be bin-packed, one-per-line or inconclusive. If it is

  /// inconclusive, e.g. completely on one line, but a decision needs to be

  /// made, clang-format analyzes whether there are other bin-packed cases in

  /// the input file and act accordingly.

  ///

  /// NOTE: This is an experimental flag, that might go away or be renamed. Do

  /// not use this in config files, etc. Use at your own risk.

  /// \version 3.7

  bool ExperimentalAutoDetectBinPacking;

 

  /// If ``true``, clang-format adds missing namespace end comments for

  /// namespaces and fixes invalid existing ones. This doesn't affect short

  /// namespaces, which are controlled by ``ShortNamespaceLines``.

  /// \code

  ///    true:                                  false:

  ///    namespace longNamespace {      vs.     namespace longNamespace {

  ///    void foo();                            void foo();

  ///    void bar();                            void bar();

  ///    } // namespace a                       }

  ///    namespace shortNamespace {             namespace shortNamespace {

  ///    void baz();                            void baz();

  ///    }                                      }

  /// \endcode

  /// \version 5

  bool FixNamespaceComments;

 

  /// A vector of macros that should be interpreted as foreach loops

  /// instead of as function calls.

  ///

  /// These are expected to be macros of the form:

  /// \code

  ///   FOREACH(<variable-declaration>, ...)

  ///     <loop-body>

  /// \endcode

  ///

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

  /// \code{.yaml}

  ///   ForEachMacros: ['RANGES_FOR', 'FOREACH']

  /// \endcode

  ///

  /// For example: BOOST_FOREACH.

  /// \version 3.7

  std::vector<std::string> ForEachMacros;

 

  tooling::IncludeStyle IncludeStyle;

 

  /// A vector of macros that should be interpreted as conditionals

  /// instead of as function calls.

  ///

  /// These are expected to be macros of the form:

  /// \code

  ///   IF(...)

  ///     <conditional-body>

  ///   else IF(...)

  ///     <conditional-body>

  /// \endcode

  ///

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

  /// \code{.yaml}

  ///   IfMacros: ['IF']

  /// \endcode

  ///

  /// For example: `KJ_IF_MAYBE

  /// <https://github.com/capnproto/capnproto/blob/master/kjdoc/tour.md#maybes>`_

  /// \version 13

  std::vector<std::string> IfMacros;

 

  /// Specify whether access modifiers should have their own indentation level.

  ///

  /// When ``false``, access modifiers are indented (or outdented) relative to

  /// the record members, respecting the ``AccessModifierOffset``. Record

  /// members are indented one level below the record.

  /// When ``true``, access modifiers get their own indentation level. As a

  /// consequence, record members are always indented 2 levels below the record,

  /// regardless of the access modifier presence. Value of the

  /// ``AccessModifierOffset`` is ignored.

  /// \code

  ///    false:                                 true:

  ///    class C {                      vs.     class C {

  ///      class D {                                class D {

  ///        void bar();                                void bar();

  ///      protected:                                 protected:

  ///        D();                                       D();

  ///      };                                       };

  ///    public:                                  public:

  ///      C();                                     C();

  ///    };                                     };

  ///    void foo() {                           void foo() {

  ///      return 1;                              return 1;

  ///    }                                      }

  /// \endcode

  /// \version 13

  bool IndentAccessModifiers;

 

  /// Indent case label blocks one level from the case label.

  ///

  /// When ``false``, the block following the case label uses the same

  /// indentation level as for the case label, treating the case label the same

  /// as an if-statement.

  /// When ``true``, the block gets indented as a scope block.

  /// \code

  ///    false:                                 true:

  ///    switch (fool) {                vs.     switch (fool) {

  ///    case 1: {                              case 1:

  ///      bar();                                 {

  ///    } break;                                   bar();

  ///    default: {                               }

  ///      plop();                                break;

  ///    }                                      default:

  ///    }                                        {

  ///                                               plop();

  ///                                             }

  ///                                           }

  /// \endcode

  /// \version 11

  bool IndentCaseBlocks;

 

  /// Indent case labels one level from the switch statement.

  ///

  /// When ``false``, use the same indentation level as for the switch

  /// statement. Switch statement body is always indented one level more than

  /// case labels (except the first block following the case label, which

  /// itself indents the code - unless IndentCaseBlocks is enabled).

  /// \code

  ///    false:                                 true:

  ///    switch (fool) {                vs.     switch (fool) {

  ///    case 1:                                  case 1:

  ///      bar();                                   bar();

  ///      break;                                   break;

  ///    default:                                 default:

  ///      plop();                                  plop();

  ///    }                                      }

  /// \endcode

  /// \version 3.3

  bool IndentCaseLabels;

 

  /// Indent goto labels.

  ///

  /// When ``false``, goto labels are flushed left.

  /// \code

  ///    true:                                  false:

  ///    int f() {                      vs.     int f() {

  ///      if (foo()) {                           if (foo()) {

  ///      label1:                              label1:

  ///        bar();                                 bar();

  ///      }                                      }

  ///    label2:                                label2:

  ///      return 1;                              return 1;

  ///    }                                      }

  /// \endcode

  /// \version 10

  bool IndentGotoLabels;

 

  /// Indents extern blocks

  enum IndentExternBlockStyle : int8_t {

    /// Backwards compatible with AfterExternBlock's indenting.

    /// \code

    ///    IndentExternBlock: AfterExternBlock

    ///    BraceWrapping.AfterExternBlock: true

    ///    extern "C"

    ///    {

    ///        void foo();

    ///    }

    /// \endcode

    ///

    /// \code

    ///    IndentExternBlock: AfterExternBlock

    ///    BraceWrapping.AfterExternBlock: false

    ///    extern "C" {

    ///    void foo();

    ///    }

    /// \endcode

    IEBS_AfterExternBlock,

    /// Does not indent extern blocks.

    /// \code

    ///     extern "C" {

    ///     void foo();

    ///     }

    /// \endcode

    IEBS_NoIndent,

    /// Indents extern blocks.

    /// \code

    ///     extern "C" {

    ///       void foo();

    ///     }

    /// \endcode

    IEBS_Indent,

  };

 

  /// IndentExternBlockStyle is the type of indenting of extern blocks.

  /// \version 11

  IndentExternBlockStyle IndentExternBlock;

 

  /// Options for indenting preprocessor directives.

  enum PPDirectiveIndentStyle : int8_t {

    /// Does not indent any directives.

    /// \code

    ///    #if FOO

    ///    #if BAR

    ///    #include <foo>

    ///    #endif

    ///    #endif

    /// \endcode

    PPDIS_None,

    /// Indents directives after the hash.

    /// \code

    ///    #if FOO

    ///    #  if BAR

    ///    #    include <foo>

    ///    #  endif

    ///    #endif

    /// \endcode

    PPDIS_AfterHash,

    /// Indents directives before the hash.

    /// \code

    ///    #if FOO

    ///      #if BAR

    ///        #include <foo>

    ///      #endif

    ///    #endif

    /// \endcode

    PPDIS_BeforeHash

  };

 

  /// The preprocessor directive indenting style to use.

  /// \version 6

  PPDirectiveIndentStyle IndentPPDirectives;

 

  /// Indent the requires clause in a template. This only applies when

  /// ``RequiresClausePosition`` is ``OwnLine``, or ``WithFollowing``.

  ///

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

  /// \code

  ///    true:

  ///    template <typename It>

  ///      requires Iterator<It>

  ///    void sort(It begin, It end) {

  ///      //....

  ///    }

  ///

  ///    false:

  ///    template <typename It>

  ///    requires Iterator<It>

  ///    void sort(It begin, It end) {

  ///      //....

  ///    }

  /// \endcode

  /// \version 15

  bool IndentRequiresClause;

 

  /// The number of columns to use for indentation.

  /// \code

  ///    IndentWidth: 3

  ///

  ///    void f() {

  ///       someFunction();

  ///       if (true, false) {

  ///          f();

  ///       }

  ///    }

  /// \endcode

  /// \version 3.7

  unsigned IndentWidth;

 

  /// Indent if a function definition or declaration is wrapped after the

  /// type.

  /// \code

  ///    true:

  ///    LoooooooooooooooooooooooooooooooooooooooongReturnType

  ///        LoooooooooooooooooooooooooooooooongFunctionDeclaration();

  ///

  ///    false:

  ///    LoooooooooooooooooooooooooooooooooooooooongReturnType

  ///    LoooooooooooooooooooooooooooooooongFunctionDeclaration();

  /// \endcode

  /// \version 3.7

  bool IndentWrappedFunctionNames;

 

  /// Insert braces after control statements (``if``, ``else``, ``for``, ``do``,

  /// and ``while``) in C++ unless the control statements are inside macro

  /// definitions or the braces would enclose preprocessor directives.

  /// \warning

  ///  Setting this option to `true` could lead to incorrect code formatting due

  ///  to clang-format's lack of complete semantic information. As such, extra

  ///  care should be taken to review code changes made by this option.

  /// \endwarning

  /// \code

  ///   false:                                    true:

  ///

  ///   if (isa<FunctionDecl>(D))        vs.      if (isa<FunctionDecl>(D)) {

  ///     handleFunctionDecl(D);                    handleFunctionDecl(D);

  ///   else if (isa<VarDecl>(D))                 } else if (isa<VarDecl>(D)) {

  ///     handleVarDecl(D);                         handleVarDecl(D);

  ///   else                                      } else {

  ///     return;                                   return;

  ///                                             }

  ///

  ///   while (i--)                      vs.      while (i--) {

  ///     for (auto *A : D.attrs())                 for (auto *A : D.attrs()) {

  ///       handleAttr(A);                            handleAttr(A);

  ///                                               }

  ///                                             }

  ///

  ///   do                               vs.      do {

  ///     --i;                                      --i;

  ///   while (i);                                } while (i);

  /// \endcode

  /// \version 15

  bool InsertBraces;

 

  /// Insert a newline at end of file if missing.

  /// \version 16

  bool InsertNewlineAtEOF;

 

  /// The style of inserting trailing commas into container literals.

  enum TrailingCommaStyle : int8_t {

    /// Do not insert trailing commas.

    TCS_None,

    /// Insert trailing commas in container literals that were wrapped over

    /// multiple lines. Note that this is conceptually incompatible with

    /// bin-packing, because the trailing comma is used as an indicator

    /// that a container should be formatted one-per-line (i.e. not bin-packed).

    /// So inserting a trailing comma counteracts bin-packing.

    TCS_Wrapped,

  };

 

  /// If set to ``TCS_Wrapped`` will insert trailing commas in container

  /// literals (arrays and objects) that wrap across multiple lines.

  /// It is currently only available for JavaScript

  /// and disabled by default ``TCS_None``.

  /// ``InsertTrailingCommas`` cannot be used together with ``BinPackArguments``

  /// as inserting the comma disables bin-packing.

  /// \code

  ///   TSC_Wrapped:

  ///   const someArray = [

  ///   aaaaaaaaaaaaaaaaaaaaaaaaaa,

  ///   aaaaaaaaaaaaaaaaaaaaaaaaaa,

  ///   aaaaaaaaaaaaaaaaaaaaaaaaaa,

  ///   //                        ^ inserted

  ///   ]

  /// \endcode

  /// \version 11

  TrailingCommaStyle InsertTrailingCommas;

 

  /// Separator format of integer literals of different bases.

  ///

  /// If negative, remove separators. If  ``0``, leave the literal as is. If

  /// positive, insert separators between digits starting from the rightmost

  /// digit.

  ///

  /// For example, the config below will leave separators in binary literals

  /// alone, insert separators in decimal literals to separate the digits into

  /// groups of 3, and remove separators in hexadecimal literals.

  /// \code

  ///   IntegerLiteralSeparator:

  ///     Binary: 0

  ///     Decimal: 3

  ///     Hex: -1

  /// \endcode

  ///

  /// You can also specify a minimum number of digits (``BinaryMinDigits``,

  /// ``DecimalMinDigits``, and ``HexMinDigits``) the integer literal must

  /// have in order for the separators to be inserted.

  struct IntegerLiteralSeparatorStyle {

    /// Format separators in binary literals.

    /// \code{.text}

    ///   /* -1: */ b = 0b100111101101;

    ///   /*  0: */ b = 0b10011'11'0110'1;

    ///   /*  3: */ b = 0b100'111'101'101;

    ///   /*  4: */ b = 0b1001'1110'1101;

    /// \endcode

    int8_t Binary;

    /// Format separators in binary literals with a minimum number of digits.

    /// \code{.text}

    ///   // Binary: 3

    ///   // BinaryMinDigits: 7

    ///   b1 = 0b101101;

    ///   b2 = 0b1'101'101;

    /// \endcode

    int8_t BinaryMinDigits;

    /// Format separators in decimal literals.

    /// \code{.text}

    ///   /* -1: */ d = 18446744073709550592ull;

    ///   /*  0: */ d = 184467'440737'0'95505'92ull;

    ///   /*  3: */ d = 18'446'744'073'709'550'592ull;

    /// \endcode

    int8_t Decimal;

    /// Format separators in decimal literals with a minimum number of digits.

    /// \code{.text}

    ///   // Decimal: 3

    ///   // DecimalMinDigits: 5

    ///   d1 = 2023;

    ///   d2 = 10'000;

    /// \endcode

    int8_t DecimalMinDigits;

    /// Format separators in hexadecimal literals.

    /// \code{.text}

    ///   /* -1: */ h = 0xDEADBEEFDEADBEEFuz;

    ///   /*  0: */ h = 0xDEAD'BEEF'DE'AD'BEE'Fuz;

    ///   /*  2: */ h = 0xDE'AD'BE'EF'DE'AD'BE'EFuz;

    /// \endcode

    int8_t Hex;

    /// Format separators in hexadecimal literals with a minimum number of

    /// digits.

    /// \code{.text}

    ///   // Hex: 2

    ///   // HexMinDigits: 6

    ///   h1 = 0xABCDE;

    ///   h2 = 0xAB'CD'EF;

    /// \endcode

    int8_t HexMinDigits;

    bool operator==(const IntegerLiteralSeparatorStyle &R) const {

      return Binary == R.Binary && BinaryMinDigits == R.BinaryMinDigits &&

             Decimal == R.Decimal && DecimalMinDigits == R.DecimalMinDigits &&

             Hex == R.Hex && HexMinDigits == R.HexMinDigits;

    }

  };

 

  /// Format integer literal separators (``'`` for C++ and ``_`` for C#, Java,

  /// and JavaScript).

  /// \version 16

  IntegerLiteralSeparatorStyle IntegerLiteralSeparator;

 

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

  ///

  /// One group's prefix can be a subset of another - the longest prefix is

  /// always matched. Within a group, the imports are ordered lexicographically.

  /// Static imports are grouped separately and follow the same group rules.

  /// By default, static imports are placed before non-static imports,

  /// but this behavior is changed by another option,

  /// ``SortJavaStaticImport``.

  ///

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

  /// in the following yaml example. This will result in imports being

  /// formatted as in the Java example below.

  /// \code{.yaml}

  ///   JavaImportGroups: ['com.example', 'com', 'org']

  /// \endcode

  ///

  /// \code{.java}

  ///    import static com.example.function1;

  ///

  ///    import static com.test.function2;

  ///

  ///    import static org.example.function3;

  ///

  ///    import com.example.ClassA;

  ///    import com.example.Test;

  ///    import com.example.a.ClassB;

  ///

  ///    import com.test.ClassC;

  ///

  ///    import org.example.ClassD;

  /// \endcode

  /// \version 8

  std::vector<std::string> JavaImportGroups;