[format] Use int8_t as the underlying type of all enums in FormatStyle

[kwk]

Summary

It was requested here (https://reviews.llvm.org/D120398#3353053) to make
the underlying type of all enums in FormatStyle an int8_t.

Originally the type was changed in https://reviews.llvm.org/D93758.

[HazardyKnusperkeks]

Please use the clang-format tag.

[kwk]

In D120884#3356746, @HazardyKnusperkeks wrote:

Please use the clang-format tag.

Yes, sorry that I forgot it again. And thank you for approving. Shall I wait for the others to approve this or land the patch?

[HazardyKnusperkeks]

In D120884#3356751, @kwk wrote:

In D120884#3356746, @HazardyKnusperkeks wrote:

Please use the clang-format tag.

Yes, sorry that I forgot it again. And thank you for approving. Shall I wait for the others to approve this or land the patch?

I myself give patches always some time. Others commit nearly as soon as possible.
I would say you can land it, but maybe wait a day, to see if someone might object.

[kwk]

Rebased

[kwk]

Fixup

[kwk]

Fixup my work after interruption by screaming children wanting dinner ;)

This is how I've tested this patch:

ninja clang-format && ninja FormatTests && ./tools/clang/unittests/Format/FormatTests

[kwk]

@HazardyKnusperkeks @owenpan can you please have a quick look again. All I did was rebasing my changes and in the meantime I was interrupted... This patch has been sitting for some time and I'd like to land it as soon one of you approves it.

[owenpan]

Should we also simplify the regex https://github.com/llvm/llvm-project/blob/a3248e4b28ce09c3a749ecae5378dd0b3a8d42b1/clang/docs/tools/dump_format_style.py#L263?

clang/include/clang/Format/Format.h

struct FormatStyle {
   // 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 : unsigned char {
+  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
struct FormatStyle {
   /// 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 {
+  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,     "!!"   }
     ///   };
struct FormatStyle {
   /// 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);
-    }
+  /// Styles for alignment of consecutive tokens. Tokens can be assignment signs
+  /// (see
+  /// ``AlignConsecutiveAssignments``), bitfield member separators (see
+  /// ``AlignConsecutiveBitFields``), names in declarations (see
+  /// ``AlignConsecutiveDeclarations``) or macro definitions (see
+  /// ``AlignConsecutiveMacros``).
+  enum AlignConsecutiveStyle : int8_t {
+    ACS_None,
+    ACS_Consecutive,
+    ACS_AcrossEmptyLines,
+    ACS_AcrossComments,
+    ACS_AcrossEmptyLinesAndComments
   };
 
   /// Style of aligning consecutive macro definitions.
   ///
   /// ``Consecutive`` will result in formattings like:
   /// \code
   ///   #define SHORT_NAME       42
   ///   #define LONGER_NAME      0x007f
struct FormatStyle {
   ///   int         aaaa = 12;
   ///   float       b = 23;
   ///   std::string ccc;
   /// \endcode
   /// \version 3.8
   AlignConsecutiveStyle AlignConsecutiveDeclarations;
 
   /// Different styles for aligning escaped newlines.
-  enum EscapedNewlineAlignmentStyle : unsigned char {
+  enum EscapedNewlineAlignmentStyle : int8_t {
     /// Don't align escaped newlines.
     /// \code
     ///   #define A \
     ///     int aaaa; \
     ///     int b; \
     ///     int dddddddddd;
     /// \endcode
     ENAS_DontAlign,
enum EscapedNewlineAlignmentStyle : int8_t {
     ENAS_Right,
   };
 
   /// Options for aligning backslashes in escaped newlines.
   /// \version 5
   EscapedNewlineAlignmentStyle AlignEscapedNewlines;
 
   /// Different styles for aligning operands.
-  enum OperandAlignmentStyle : unsigned char {
+  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.:
struct FormatStyle {
   ///     B
   ///   } myEnum;
   /// \endcode
   /// \version 11
   bool AllowShortEnumsOnASingleLine;
 
   /// Different styles for merging short blocks containing at most one
   /// statement.
-  enum ShortBlockStyle : unsigned char {
+  enum ShortBlockStyle : int8_t {
     /// Never merge blocks into a single line.
     /// \code
     ///   while (true) {
     ///   }
     ///   while (true) {
     ///     continue;
     ///   }
     /// \endcode
struct FormatStyle {
   ///                                             return;
   ///                                           }
   /// \endcode
   /// \version 3.6
   bool AllowShortCaseLabelsOnASingleLine;
 
   /// Different styles for merging short functions containing at most one
   /// statement.
-  enum ShortFunctionStyle : unsigned char {
+  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(); }
struct FormatStyle {
   };
 
   /// 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 : unsigned char {
+  enum ShortIfStyle : int8_t {
     /// Never put short ifs on the same line.
     /// \code
     ///   if (a)
     ///     return;
     ///
     ///   if (b)
     ///     return;
     ///   else
struct FormatStyle {
   };
 
   /// Dependent on the value, ``if (a) return;`` can be put on a single line.
   /// \version 9
   ShortIfStyle AllowShortIfStatementsOnASingleLine;
 
   /// Different styles for merging short lambdas containing at most one
   /// statement.
-  enum ShortLambdaStyle : unsigned char {
+  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;
     ///   };
struct FormatStyle {
 
   /// 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 : unsigned char {
+  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 : unsigned char {
+  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; }
struct FormatStyle {
   ///    aaaa =                         vs.     aaaa = "bbbb"
   ///        "bbbb"                                    "cccc";
   ///        "cccc";
   /// \endcode
   /// \version 3.4
   bool AlwaysBreakBeforeMultilineStrings;
 
   /// Different ways to break after the template declaration.
-  enum BreakTemplateDeclarationsStyle : unsigned char {
+  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) {
     ///    }
struct FormatStyle {
   ///       aaaaaaaaaaaaaaaaaaaa,
   ///       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
   ///   }
   /// \endcode
   /// \version 3.7
   bool BinPackArguments;
 
   /// The style of inserting trailing commas into container literals.
-  enum TrailingCommaStyle : unsigned char {
+  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,
struct FormatStyle {
   ///          int aaaaaaaaaaaaaaaaaaaa,
   ///          int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
   /// \endcode
   /// \version 3.7
   bool BinPackParameters;
 
   /// The style of wrapping parameters on the same line (bin-packed) or
   /// on one line each.
-  enum BinPackStyle : unsigned char {
+  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 : unsigned char {
+  enum BinaryOperatorStyle : int8_t {
     /// Break after operators.
     /// \code
     ///    LooooooooooongType loooooooooooooooooooooongVariable =
     ///        someLooooooooooooooooongFunction();
     ///
     ///    bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +
     ///                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==
     ///                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
enum BinaryOperatorStyle : int8_t {
     BOS_All,
   };
 
   /// The way to wrap binary operators.
   /// \version 3.6
   BinaryOperatorStyle BreakBeforeBinaryOperators;
 
   /// Different ways to attach braces to their surrounding context.
-  enum BraceBreakingStyle : unsigned char {
+  enum BraceBreakingStyle : int8_t {
     /// Always attach braces to surrounding context.
     /// \code
     ///   namespace N {
     ///   enum E {
     ///     E1,
     ///     E2,
     ///   };
     ///
enum BraceBreakingStyle : int8_t {
     BS_Custom
   };
 
   /// The brace breaking style to use.
   /// \version 3.7
   BraceBreakingStyle BreakBeforeBraces;
 
   /// Different ways to wrap braces after control statements.
-  enum BraceWrappingAfterControlStatementStyle : unsigned char {
+  enum BraceWrappingAfterControlStatementStyle : int8_t {
     /// Never wrap braces after a control statement.
     /// \code
     ///   if (foo()) {
     ///   } else {
     ///   }
     ///   for (int i = 0; i < 10; ++i) {
     ///   }
     /// \endcode

   ///     AfterEnum: true
   ///     AfterStruct: false
   ///     SplitEmptyFunction: false
   /// \endcode
   /// \version 3.8
   BraceWrappingFlags BraceWrapping;
 
   /// Different ways to break before concept declarations.
-  enum BreakBeforeConceptDeclarationsStyle {
+  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.

   ///    veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
   ///        firstValue :
   ///        SecondValueVeryVeryVeryVeryLong;
   /// \endcode
   /// \version 3.7
   bool BreakBeforeTernaryOperators;
 
   /// Different ways to break initializers.
-  enum BreakConstructorInitializersStyle : unsigned char {
+  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

   ///    // CommentPragmas: '^ FOOBAR pragma:'
   ///    // Will leave the following line unaffected
   ///    #include <vector> // FOOBAR pragma: keep
   /// \endcode
   /// \version 3.7
   std::string CommentPragmas;
 
   /// Different specifiers and qualifiers alignment styles.
-  enum QualifierAlignmentStyle {
+  enum QualifierAlignmentStyle : int8_t {
     /// Don't change specifiers/qualifiers to either Left or Right alignment
     /// (default).
     /// \code
     ///    int const a;
     ///    const int *a;
     /// \endcode
     QAS_Leave,
     /// Change specifiers/qualifiers to be left-aligned.

   ///
   /// \code{.yaml}
   ///   QualifierOrder: ['inline', 'static', 'type', 'const', 'volatile' ]
   /// \endcode
   /// \version 14
   std::vector<std::string> QualifierOrder;
 
   /// Different ways to break inheritance list.
-  enum BreakInheritanceListStyle : unsigned char {
+  enum BreakInheritanceListStyle : int8_t {
     /// Break inheritance list before the colon and after the commas.
     /// \code
     ///    class Foo
     ///        : Base1,
     ///          Base2
     ///    {};
     /// \endcode
     BILS_BeforeColon,

 
   /// 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 : unsigned char {
+  enum EmptyLineAfterAccessModifierStyle : int8_t {
     /// Remove all empty lines after access modifiers.
     /// \code
     ///   struct foo {
     ///   private:
     ///     int i;
     ///   protected:
     ///     int j;
     ///     /* comment */

 
   /// 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 : unsigned char {
+  enum EmptyLineBeforeAccessModifierStyle : int8_t {
     /// Remove all empty lines before access modifiers.
     /// \code
     ///   struct foo {
     ///   private:
     ///     int i;
     ///   protected:
     ///     int j;
     ///     /* comment */

   /// 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;
 
   /// Different ways to try to fit all constructor initializers on a line.
-  enum PackConstructorInitializersStyle : unsigned char {
+  enum PackConstructorInitializersStyle : int8_t {
     /// Always put each constructor initializer on its own line.
     /// \code
     ///    Constructor()
     ///        : a(),
     ///          b()
     /// \endcode
     PCIS_Never,
     /// Bin-pack constructor initializers.

   ///    label2:                                label2:
   ///      return 1;                              return 1;
   ///    }                                      }
   /// \endcode
   /// \version 10
   bool IndentGotoLabels;
 
   /// Options for indenting preprocessor directives.
-  enum PPDirectiveIndentStyle : unsigned char {
+  enum PPDirectiveIndentStyle : int8_t {
     /// Does not indent any directives.
     /// \code
     ///    #if FOO
     ///    #if BAR
     ///    #include <foo>
     ///    #endif
     ///    #endif
     /// \endcode
enum PPDirectiveIndentStyle : int8_t {
     PPDIS_BeforeHash
   };
 
   /// The preprocessor directive indenting style to use.
   /// \version 6
   PPDirectiveIndentStyle IndentPPDirectives;
 
   /// Indents extern blocks
-  enum IndentExternBlockStyle : unsigned char {
+  enum IndentExternBlockStyle : int8_t {
     /// Backwards compatible with AfterExternBlock's indenting.
     /// \code
     ///    IndentExternBlock: AfterExternBlock
     ///    BraceWrapping.AfterExternBlock: true
     ///    extern "C"
     ///    {
     ///        void foo();
     ///    }

   ///
   ///    import org.example.ClassD;
   /// \endcode
   /// \version 8
   std::vector<std::string> JavaImportGroups;
 
   /// Quotation styles for JavaScript strings. Does not affect template
   /// strings.
-  enum JavaScriptQuoteStyle : unsigned char {
+  enum JavaScriptQuoteStyle : int8_t {
     /// Leave string quotes as they are.
     /// \code{.js}
     ///    string1 = "foo";
     ///    string2 = 'bar';
     /// \endcode
     JSQS_Leave,
     /// Always use single quotes.
     /// \code{.js}

   /// \version 3.7
   bool KeepEmptyLinesAtTheStartOfBlocks;
 
   /// Supported languages.
   ///
   /// When stored in a configuration file, specifies the language, that the
   /// configuration targets. When passed to the ``reformat()`` function, enables
   /// syntax features specific to the language.
-  enum LanguageKind : unsigned char {
+  enum LanguageKind : int8_t {
     /// Do not use.
     LK_None,
     /// Should be used for C, C++.
     LK_Cpp,
     /// Should be used for C#.
     LK_CSharp,
     /// Should be used for Java.
     LK_Java,

   bool isJson() const { return Language == LK_Json; }
   bool isJavaScript() const { return Language == LK_JavaScript; }
 
   /// Language, this format style is targeted at.
   /// \version 3.5
   LanguageKind Language;
 
   /// Indentation logic for lambda bodies.
-  enum LambdaBodyIndentationKind : unsigned char {
+  enum LambdaBodyIndentationKind : int8_t {
     /// Align lambda body relative to the lambda signature. This is the default.
     /// \code
     ///    someMethod(
     ///        [](SomeReallyLongLambdaSignatureArgument foo) {
     ///          return;
     ///        });
     /// \endcode
     LBI_Signature,
///    NS_TABLE_.*_END$"
   ///                                           }
   ///      return i;
   ///    }
   /// \endcode
   /// \version 3.7
   unsigned MaxEmptyLinesToKeep;
 
   /// Different ways to indent namespace contents.
-  enum NamespaceIndentationKind : unsigned char {
+  enum NamespaceIndentationKind : int8_t {
     /// Don't indent in namespaces.
     /// \code
     ///    namespace out {
     ///    int i;
     ///    namespace in {
     ///    int i;
     ///    }
     ///    }
///    NS_TABLE_.*_END$"
   unsigned PenaltyReturnTypeOnItsOwnLine;
 
   /// Penalty for each character of whitespace indentation
   /// (counted relative to leading non-whitespace column).
   /// \version 12
   unsigned PenaltyIndentedWhitespace;
 
   /// The ``&``, ``&&`` and ``*`` alignment style.
-  enum PointerAlignmentStyle : unsigned char {
+  enum PointerAlignmentStyle : int8_t {
     /// Align pointer to the left.
     /// \code
     ///   int* a;
     /// \endcode
     PAS_Left,
     /// Align pointer to the right.
     /// \code
     ///   int *a;
///    NS_TABLE_.*_END$"
   ///           - 'cpp'
   ///         BasedOnStyle: llvm
   ///         CanonicalDelimiter: 'cc'
   /// \endcode
   /// \version 6
   std::vector<RawStringFormat> RawStringFormats;
 
   /// \brief The ``&`` and ``&&`` alignment style.
-  enum ReferenceAlignmentStyle {
+  enum ReferenceAlignmentStyle : int8_t {
     /// Align reference like ``PointerAlignment``.
     RAS_Pointer,
     /// Align reference to the left.
     /// \code
     ///   int& a;
     /// \endcode
     RAS_Left,
     /// Align reference to the right.
///    NS_TABLE_.*_END$"
   ///   }
   /// \endcode
   /// \version 14
   bool RemoveBracesLLVM;
 
   /// \brief The possible positions for the requires clause. The
   /// ``IndentRequires`` option is only used if the ``requires`` is put on the
   /// start of a line.
-  enum RequiresClausePositionStyle {
+  enum RequiresClausePositionStyle : int8_t {
     /// Always put the ``requires`` clause on its own line.
     /// \code
     ///   template <typename T>
     ///   requires C<T>
     ///   struct Foo {...
     ///
     ///   template <typename T>
     ///   requires C<T>
enum RequiresClausePositionStyle : int8_t {
     RCPS_SingleLine,
   };
 
   /// \brief The position of the ``requires`` clause.
   /// \version 15
   RequiresClausePositionStyle RequiresClausePosition;
 
   /// \brief The style if definition blocks should be separated.
-  enum SeparateDefinitionStyle {
+  enum SeparateDefinitionStyle : int8_t {
     /// Leave definition blocks as they are.
     SDS_Leave,
     /// Insert an empty line between definition blocks.
     SDS_Always,
     /// Remove any empty line between definition blocks.
     SDS_Never
   };
 
///    NS_TABLE_.*_END$"
   ///      int foo;                           int foo;
   ///      int bar;                           int bar;
   ///    } // namespace b                   } // namespace b
   /// \endcode
   /// \version 13
   unsigned ShortNamespaceLines;
 
   /// Include sorting options.
-  enum SortIncludesOptions : unsigned char {
+  enum SortIncludesOptions : int8_t {
     /// Includes are never sorted.
     /// \code
     ///    #include "B/A.h"
     ///    #include "A/B.h"
     ///    #include "a/b.h"
     ///    #include "A/b.h"
     ///    #include "B/a.h"
     /// \endcode
///    NS_TABLE_.*_END$"
   /// If ``CaseInsensitive``, includes are sorted in an ASCIIbetical or case
   /// insensitive fashion.
   /// If ``CaseSensitive``, includes are sorted in an alphabetical or case
   /// sensitive fashion.
   /// \version 4
   SortIncludesOptions SortIncludes;
 
   /// Position for Java Static imports.
-  enum SortJavaStaticImportOptions : unsigned char {
+  enum SortJavaStaticImportOptions : int8_t {
     /// Static imports are placed before non-static imports.
     /// \code{.java}
     ///   import static org.example.function1;
     ///
     ///   import org.example.ClassA;
     /// \endcode
     SJSIO_Before,
     /// Static imports are placed after non-static imports.
///    NS_TABLE_.*_END$"
   /// \code
   ///    true:                                  false:
   ///    template <int> void foo();     vs.     template<int> void foo();
   /// \endcode
   /// \version 4
   bool SpaceAfterTemplateKeyword;
 
   /// Different ways to put a space before opening parentheses.
-  enum SpaceAroundPointerQualifiersStyle : unsigned char {
+  enum SpaceAroundPointerQualifiersStyle : int8_t {
     /// Don't ensure spaces around pointer qualifiers and use PointerAlignment
     /// instead.
     /// \code
     ///    PointerAlignment: Left                 PointerAlignment: Right
     ///    void* const* x = NULL;         vs.     void *const *x = NULL;
     /// \endcode
     SAPQ_Default,
     /// Ensure that there is a space before pointer qualifiers.
///    NS_TABLE_.*_END$"
   /// \code
   ///    true:                                  false:
   ///    class Foo : Bar {}             vs.     class Foo: Bar {}
   /// \endcode
   /// \version 7
   bool SpaceBeforeInheritanceColon;
 
   /// Different ways to put a space before opening parentheses.
-  enum SpaceBeforeParensStyle : unsigned char {
+  enum SpaceBeforeParensStyle : int8_t {
     /// Never put a space before opening parentheses.
     /// \code
     ///    void f() {
     ///      if(true) {
     ///        f();
     ///      }
     ///    }
     /// \endcode
///    NS_TABLE_.*_END$"
   ///      }             // foo
   ///    }
   /// \endcode
   /// \version 3.7
   unsigned SpacesBeforeTrailingComments;
 
   /// Styles for adding spacing after ``<`` and before ``>`
   ///  in template argument lists.
-  enum SpacesInAnglesStyle : unsigned char {
+  enum SpacesInAnglesStyle : int8_t {
     /// Remove spaces after ``<`` and before ``>``.
     /// \code
     ///    static_cast<int>(arg);
     ///    std::function<void(int)> fct;
     /// \endcode
     SIAS_Never,
     /// Add spaces after ``<`` and before ``>``.
     /// \code

   ///    true:                                  false:
   ///    int a [5];                    vs.      int a[5];
   ///    int a [5][5];                 vs.      int a[5][5];
   /// \endcode
   /// \version 11
   bool SpaceBeforeSquareBrackets;
 
   /// Styles for adding spacing around ``:`` in bitfield definitions.
-  enum BitFieldColonSpacingStyle : unsigned char {
+  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

   /// Supported language standards for parsing and formatting C++ constructs.
   /// \code
   ///    Latest:                                vector<set<int>>
   ///    c++03                          vs.     vector<set<int> >
   /// \endcode
   ///
   /// The correct way to spell a specific language version is e.g. ``c++11``.
   /// The historical aliases ``Cpp03`` and ``Cpp11`` are deprecated.
-  enum LanguageStandard : unsigned char {
+  enum LanguageStandard : int8_t {
     /// Parse and format as C++03.
     /// ``Cpp03`` is a deprecated alias for ``c++03``
     LS_Cpp03, // c++03
     /// Parse and format as C++11.
     LS_Cpp11, // c++11
     /// Parse and format as C++14.
     LS_Cpp14, // c++14
     /// Parse and format as C++17.

   /// \version 12
   std::vector<std::string> StatementAttributeLikeMacros;
 
   /// The number of columns used for tab stops.
   /// \version 3.7
   unsigned TabWidth;
 
   /// Different ways to use tab in formatting.
-  enum UseTabStyle : unsigned char {
+  enum UseTabStyle : int8_t {
     /// Never use tab.
     UT_Never,
     /// Use tabs only for indentation.
     UT_ForIndentation,
     /// Fill all leading whitespace with tabs, and use spaces for alignment that
     /// appears within a line (e.g. consecutive assignments and declarations).
     UT_ForContinuationAndIndentation,
     /// Use tabs for line continuation and indentation, and spaces for