[format][NFC] Use unsigned char as the base of all enums in FormatStyle

[njames93]

Summary

This removes alot of unnecessary padding, trimming the size of the struct from 728->608 on 64 bit platforms.

[MyDeveloperDay]

We should probably check the docs/tools/dump_format_style.py still works

[njames93]

In D93758#2469967, @MyDeveloperDay wrote:

We should probably check the docs/tools/dump_format_style.py still works

Good catch, I'll update the script to optionally take an underlying type argument. Should that be part of this change, or a parent?

[njames93]

• Update dump_format_style script

Only tweaked regex to support enum <name> : <words> ... {
Decided there wasn't much to gain from supporting nested types etc

[MyDeveloperDay]

I don't have any major issues with this other than it makes Format.h a bit more ugly. (there are more ugly and harder to understand pieces of code than this change!)

We'll only normally really have 1 of these in play at any one time, but it is passed around quite a bit on the stack, should we care about the extra space it's taking? (I'm ok if the answer is "yes we should")

[njames93]

In D93758#2470124, @MyDeveloperDay wrote:

I don't have any major issues with this other than it makes Format.h a bit more ugly. (there are more ugly and harder to understand pieces of code than this change!)

We'll only normally really have 1 of these in play at any one time, but it is passed around quite a bit on the stack, should we care about the extra space it's taking? (I'm ok if the answer is "yes we should")

We only keep one instance on the stack in clang-format. But in tools that embed clang format we may keep more than 1 around. In clangd we are hoping to cache format styles for each file(well directory). As these cached items will live on the heap, saving about 16% from the size is worth it.

[HazardyKnusperkeks]

This went totally over my head.

clang/docs/tools/dump_format_style.py

elif state == State.InStruct:
       elif line == '};':
         state = State.Finished
         break
     elif state == State.InFieldComment:
       if line.startswith('///'):
         comment += clean_comment_line(line)
       elif line.startswith('enum'):
         state = State.InEnum
-        name = re.sub(r'enum\s+(\w+)\s*\{', '\\1', line)
+        name = re.sub(r'enum\s+(\w+)\s*(:((\s*\w+)+)\s*)?\{', '\\1', line)
         enum = Enum(name, comment)
       elif line.startswith('struct'):
         state = State.InNestedStruct
         name = re.sub(r'struct\s+(\w+)\s*\{', '\\1', line)
         nested_struct = NestedStruct(name, comment)
       elif line.endswith(';'):
         state = State.InStruct
         field_type, field_name = re.match(r'([<>:\w(,\s)]+)\s+(\w+);',

clang/include/clang/Format/Format.h

 
 /// The ``FormatStyle`` is used to configure the formatting to follow
 /// specific guidelines.
 struct FormatStyle {
   /// The extra indent or outdent of access modifiers, e.g. ``public:``.
   int AccessModifierOffset;
 
   /// Different styles for aligning after open brackets.
-  enum BracketAlignmentStyle {
+  enum BracketAlignmentStyle : unsigned char {
     /// 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 {
   /// \code
   ///   int         aaaa = 12;
   ///   float       b = 23;
   ///   std::string ccc = 23;
   /// \endcode
   bool AlignConsecutiveDeclarations;
 
   /// Different styles for aligning escaped newlines.
-  enum EscapedNewlineAlignmentStyle {
+  enum EscapedNewlineAlignmentStyle : unsigned char {
     /// Don't align escaped newlines.
     /// \code
     ///   #define A \
     ///     int aaaa; \
     ///     int b; \
     ///     int dddddddddd;
     /// \endcode
     ENAS_DontAlign,
enum EscapedNewlineAlignmentStyle : unsigned char {
     /// \endcode
     ENAS_Right,
   };
 
   /// Options for aligning backslashes in escaped newlines.
   EscapedNewlineAlignmentStyle AlignEscapedNewlines;
 
   /// Different styles for aligning operands.
-  enum OperandAlignmentStyle {
+  enum OperandAlignmentStyle : unsigned char {
     /// 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 {
   ///     A,
   ///     B
   ///   } myEnum;
   /// \endcode
   bool AllowShortEnumsOnASingleLine;
 
   /// Different styles for merging short blocks containing at most one
   /// statement.
-  enum ShortBlockStyle {
+  enum ShortBlockStyle : unsigned char {
     /// Never merge blocks into a single line.
     /// \code
     ///   while (true) {
     ///   }
     ///   while (true) {
     ///     continue;
     ///   }
     /// \endcode
struct FormatStyle {
   ///                                           case 2:
   ///                                             return;
   ///                                           }
   /// \endcode
   bool AllowShortCaseLabelsOnASingleLine;
 
   /// Different styles for merging short functions containing at most one
   /// statement.
-  enum ShortFunctionStyle {
+  enum ShortFunctionStyle : unsigned char {
     /// 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(); }
enum ShortFunctionStyle : unsigned char {
     SFS_All,
   };
 
   /// Dependent on the value, ``int f() { return 0; }`` can be put on a
   /// single line.
   ShortFunctionStyle AllowShortFunctionsOnASingleLine;
 
   /// Different styles for handling short if lines
-  enum ShortIfStyle {
+  enum ShortIfStyle : unsigned char {
     /// Never put short ifs on the same line.
     /// \code
     ///   if (a)
     ///     return ;
     ///   else {
     ///     return;
     ///   }
     /// \endcode
enum ShortIfStyle : unsigned char {
     SIS_Always,
   };
 
   /// If ``true``, ``if (a) return;`` can be put on a single line.
   ShortIfStyle AllowShortIfStatementsOnASingleLine;
 
   /// Different styles for merging short lambdas containing at most one
   /// statement.
-  enum ShortLambdaStyle {
+  enum ShortLambdaStyle : unsigned char {
     /// 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 {
   ShortLambdaStyle AllowShortLambdasOnASingleLine;
 
   /// If ``true``, ``while (true) continue;`` can be put on a single
   /// line.
   bool AllowShortLoopsOnASingleLine;
 
   /// Different ways to break after the function definition return type.
   /// This option is **deprecated** and is retained for backwards compatibility.
-  enum DefinitionReturnTypeBreakingStyle {
+  enum DefinitionReturnTypeBreakingStyle : unsigned char {
     /// 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 {
+  enum ReturnTypeBreakingStyle : unsigned char {
     /// 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 {
   ///    true:                                  false:
   ///    aaaa =                         vs.     aaaa = "bbbb"
   ///        "bbbb"                                    "cccc";
   ///        "cccc";
   /// \endcode
   bool AlwaysBreakBeforeMultilineStrings;
 
   /// Different ways to break after the template declaration.
-  enum BreakTemplateDeclarationsStyle {
+  enum BreakTemplateDeclarationsStyle : unsigned char {
     /// 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 {
   ///     f(aaaaaaaaaaaaaaaaaaaa,
   ///       aaaaaaaaaaaaaaaaaaaa,
   ///       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
   ///   }
   /// \endcode
   bool BinPackArguments;
 
   /// The style of inserting trailing commas into container literals.
-  enum TrailingCommaStyle {
+  enum TrailingCommaStyle : unsigned char {
     /// 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 {
   ///   void f(int aaaaaaaaaaaaaaaaaaaa,
   ///          int aaaaaaaaaaaaaaaaaaaa,
   ///          int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
   /// \endcode
   bool BinPackParameters;
 
   /// The style of wrapping parameters on the same line (bin-packed) or
   /// on one line each.
-  enum BinPackStyle {
+  enum BinPackStyle : unsigned char {
     /// 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 {
+  enum BinaryOperatorStyle : unsigned char {
     /// Break after operators.
     /// \code
     ///    LooooooooooongType loooooooooooooooooooooongVariable =
     ///        someLooooooooooooooooongFunction();
     ///
     ///    bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +
     ///                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==
     ///                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
enum BinaryOperatorStyle : unsigned char {
     /// \endcode
     BOS_All,
   };
 
   /// The way to wrap binary operators.
   BinaryOperatorStyle BreakBeforeBinaryOperators;
 
   /// Different ways to attach braces to their surrounding context.
-  enum BraceBreakingStyle {
+  enum BraceBreakingStyle : unsigned char {
     /// Always attach braces to surrounding context.
     /// \code
     ///   namespace N {
     ///   enum E {
     ///     E1,
     ///     E2,
     ///   };
     ///
enum BraceBreakingStyle : unsigned char {
     /// Configure each individual brace in `BraceWrapping`.
     BS_Custom
   };
 
   /// The brace breaking style to use.
   BraceBreakingStyle BreakBeforeBraces;
 
   /// Different ways to wrap braces after control statements.
-  enum BraceWrappingAfterControlStatementStyle {
+  enum BraceWrappingAfterControlStatementStyle : unsigned char {
     /// Never wrap braces after a control statement.
     /// \code
     ///   if (foo()) {
     ///   } else {
     ///   }
     ///   for (int i = 0; i < 10; ++i) {
     ///   }
     /// \endcode

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

   /// \code
   ///    // CommentPragmas: '^ FOOBAR pragma:'
   ///    // Will leave the following line unaffected
   ///    #include <vector> // FOOBAR pragma: keep
   /// \endcode
   std::string CommentPragmas;
 
   /// Different ways to break inheritance list.
-  enum BreakInheritanceListStyle {
+  enum BreakInheritanceListStyle : unsigned char {
     /// Break inheritance list before the colon and after the commas.
     /// \code
     ///    class Foo
     ///        : Base1,
     ///          Base2
     ///    {};
     /// \endcode
     BILS_BeforeColon,

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

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

   /// \endcode
   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 {
+  enum LanguageKind : unsigned char {
     /// 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,

   ///      i = foo();                               return i;
   ///                                           }
   ///      return i;
   ///    }
   /// \endcode
   unsigned MaxEmptyLinesToKeep;
 
   /// Different ways to indent namespace contents.
-  enum NamespaceIndentationKind {
+  enum NamespaceIndentationKind : unsigned char {
     /// Don't indent in namespaces.
     /// \code
     ///    namespace out {
     ///    int i;
     ///    namespace in {
     ///    int i;
     ///    }
     ///    }

   /// line.
   unsigned PenaltyReturnTypeOnItsOwnLine;
 
   /// Penalty for each character of whitespace indentation
   /// (counted relative to leading non-whitespace column).
   unsigned PenaltyIndentedWhitespace;
 
   /// The ``&`` and ``*`` alignment style.
-  enum PointerAlignmentStyle {
+  enum PointerAlignmentStyle : unsigned char {
     /// Align pointer to the left.
     /// \code
     ///   int* a;
     /// \endcode
     PAS_Left,
     /// Align pointer to the right.
     /// \code
     ///   int *a;

   /// \code
   ///    false:                                 true:
   ///    #include "b.h"                 vs.     #include "a.h"
   ///    #include "a.h"                         #include "b.h"
   /// \endcode
   bool SortIncludes;
 
   /// Position for Java Static imports.
-  enum SortJavaStaticImportOptions {
+  enum SortJavaStaticImportOptions : unsigned char {
     /// 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.

   /// If \c true, a space will be inserted after the 'template' keyword.
   /// \code
   ///    true:                                  false:
   ///    template <int> void foo();     vs.     template<int> void foo();
   /// \endcode
   bool SpaceAfterTemplateKeyword;
 
   /// Different ways to put a space before opening parentheses.
-  enum SpaceAroundPointerQualifiersStyle {
+  enum SpaceAroundPointerQualifiersStyle : unsigned char {
     /// 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.

   /// If ``false``, spaces will be removed before inheritance colon.
   /// \code
   ///    true:                                  false:
   ///    class Foo : Bar {}             vs.     class Foo: Bar {}
   /// \endcode
   bool SpaceBeforeInheritanceColon;
 
   /// Different ways to put a space before opening parentheses.
-  enum SpaceBeforeParensOptions {
+  enum SpaceBeforeParensOptions : unsigned char {
     /// Never put a space before opening parentheses.
     /// \code
     ///    void f() {
     ///      if(true) {
     ///        f();
     ///      }
     ///    }
     /// \endcode

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

   ///    vector<set<int> > x;           vs.     vector<set<int>> x;
   /// \endcode
   LanguageStandard Standard;
 
   /// The number of columns used for tab stops.
   unsigned TabWidth;
 
   /// Different ways to use tab in formatting.
-  enum UseTabStyle {
+  enum UseTabStyle : unsigned char {
     /// 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