[lldb] Add an EnumFlags class for representing flags based on enums

[teemperor]

Summary

There are many instances of Flags variables in LLDB that are not really a set of bit flags,
but actually more a list of enumerators from one of LLDB's 'flags enums' (see the FLAGS_ENUM macro
for finding most of those).

The problem with using Flags for these enums is that it's impossible to know what the actual
enum is that is being used for giving the bits in Flags any meaning. Given that the variables
are essentially never documented and often just called something like m_flags, the only way to
find the right enum is to follow the code execution until you find a line where someone accesses
one of the bits via one of the enumerators.

These variables are also very often exposed directly via the SB API, so we can't just remove all of them
and replace them with struct+bitfields or something similar.

To make dealing with those variables less fragile, I would propose adding a EnumFlags template to
LLDB. The class mirrors the normal Flags API for the most part so that we don't have to rewrite
all the code that moves to the new class, but all methods are now typed with the specific enum that
is being used to give the bits meaning. This way it's clear from just looking at the variable type what
the right enum is. Also, we can now just type all the member functions so that they now reject enumerators
from other enums, so it's now impossible to even use the wrong enum without getting a compiler error.

I migrated the Flags variables that didn't require any larger refactorings to the new class as part of the patch.
The plan is to migrate the other variables (especially the largest offender: TypeFlags) in separate follow-up
patches.

Some Questions & Answers I expect to come up in the review:

Q: Are the llvm::ArrayRef<T> arguments getting optimized to the same code as the old bitflags?
A: Yes, it's the same with -O2.

Q: Do we still need Flags?
A: Actually, there are a few uses left for this class. The class could be useful to have in LLVM
as it's nicer than just operating on plain uintX_t types, so maybe we should rewrite it and move it into
ADT or Support.

Q: Should EnumFlags be in LLVM?
A: IMHO no. I think the whole enums-as-bitfields thing can be done much simpler with bitfields. LLDB has
to keep doing it as it's exposed the SB API, but I don't think we should encourage this pattern.

[JDevlieghere]

This looks like a great improvement. Would it be possible to implement Flags in terms of EnumFlags<uint32_t> (possibly using partial specialization) and get rid of the existing class that way?

lldb/include/lldb/Utility/EnumFlags.h

114

Nit: would = {} be more "generic"?

lldb/include/lldb/DataFormatters/ValueObjectPrinter.h

 //===-- ValueObjectPrinter.h ---------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_DATAFORMATTERS_VALUEOBJECTPRINTER_H
 #define LLDB_DATAFORMATTERS_VALUEOBJECTPRINTER_H
 
 #include "lldb/lldb-private.h"
 #include "lldb/lldb-public.h"
 
-#include "lldb/Utility/Flags.h"
+#include "lldb/Utility/EnumFlags.h"
 
 #include "lldb/DataFormatters/DumpValueObjectOptions.h"
 #include "lldb/Symbol/CompilerType.h"
 
 namespace lldb_private {
 
 class ValueObjectPrinter {
 public:
protected:
 
   bool PrintChildrenOneLiner(bool hide_names);
 
 private:
   ValueObject *m_orig_valobj;
   ValueObject *m_valobj;
   Stream *m_stream;
   DumpValueObjectOptions m_options;
-  Flags m_type_flags;
+  EnumFlags<lldb::TypeFlags> m_type_flags;
   CompilerType m_compiler_type;
   DumpValueObjectOptions::PointerDepth m_ptr_depth;
   uint32_t m_curr_depth;
   LazyBool m_should_print;
   LazyBool m_is_nil;
   LazyBool m_is_uninit;
   LazyBool m_is_ptr;
   LazyBool m_is_ref;

lldb/include/lldb/Host/ProcessLaunchInfo.h

 //===-- ProcessLaunchInfo.h -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_PROCESSLAUNCHINFO_H
 #define LLDB_HOST_PROCESSLAUNCHINFO_H
 
 // C++ Headers
 #include <string>
 
 // LLDB Headers
-#include "lldb/Utility/Flags.h"
+#include "lldb/Utility/EnumFlags.h"
 
 #include "lldb/Host/FileAction.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/ProcessInfo.h"
 
 namespace lldb_private {
public:
   llvm::Error SetUpPtyRedirection();
 
   size_t GetNumFileActions() const { return m_file_actions.size(); }
 
   const FileAction *GetFileActionAtIndex(size_t idx) const;
 
   const FileAction *GetFileActionForFD(int fd) const;
 
-  Flags &GetFlags() { return m_flags; }
+  EnumFlags<lldb::LaunchFlags> &GetFlags() { return m_flags; }
 
-  const Flags &GetFlags() const { return m_flags; }
+  const EnumFlags<lldb::LaunchFlags> &GetFlags() const { return m_flags; }
 
   const FileSpec &GetWorkingDirectory() const;
 
   void SetWorkingDirectory(const FileSpec &working_dir);
 
   const char *GetProcessPluginName() const;
 
   void SetProcessPluginName(llvm::StringRef plugin);
public:
   bool GetDetachOnError() const {
     return m_flags.Test(lldb::eLaunchFlagDetachOnError);
   }
 
 protected:
   FileSpec m_working_dir;
   std::string m_plugin_name;
   FileSpec m_shell;
-  Flags m_flags; // Bitwise OR of bits from lldb::LaunchFlags
+  EnumFlags<lldb::LaunchFlags>
+      m_flags; // Bitwise OR of bits from lldb::LaunchFlags
   std::vector<FileAction> m_file_actions; // File actions for any other files
   std::shared_ptr<PseudoTerminal> m_pty;
   uint32_t m_resume_count; // How many times do we resume after launching
   Host::MonitorChildProcessCallback m_monitor_callback;
   void *m_monitor_callback_baton;
   bool m_monitor_signals;
   std::string m_event_data; // A string passed to the plugin launch, having no
                             // meaning to the upper levels of lldb.
   lldb::ListenerSP m_listener_sp;
   lldb::ListenerSP m_hijack_listener_sp;
 };
 }
 
 #endif // LLDB_HOST_PROCESSLAUNCHINFO_H

lldb/include/lldb/Utility/EnumFlags.h

+//===-- EnumFlags.h ---------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_ENUMFLAGS_H
+#define LLDB_UTILITY_ENUMFLAGS_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+namespace lldb_private {
+
+/// \class EnumFlags EnumFlags.h "lldb/Utility/EnumFlags.h"
+/// Typed wrapper for enum-based bit flags.
+///
+/// EnumFlags provides functions for reading and writing specific bits in the
+/// underlying flags storage. If possible, all functions are typed with the
+/// actual enum that is used to describe the meaning of the different bits.
+///
+/// This class supports both scoped and unscoped enums.
+template <typename T> class EnumFlags {
+  /// The integer type that can store all the bits that can be described by
+  /// the enumerators of this specialization.
+  typedef std::underlying_type_t<T> ValueType;
+  /// Utility function for converting the enum type to the used ValueType.
+  static ValueType ToValueType(T e) { return static_cast<ValueType>(e); }
+
+  /// Bitwise ORs all passed enumerators into a integer compatible with the
+  /// internal integer storage for the flags.
+  static ValueType MergeEnumArgs(llvm::ArrayRef<T> flags) {
+    ValueType Merged = 0;
+    for (T e : flags)
+      Merged |= ToValueType(e);
+    return Merged;
+  }
+
+public:
+  EnumFlags() = default;
+  explicit EnumFlags(llvm::ArrayRef<T> flags) { Set(flags); }
+
+  /// Clears all flags.
+  void Clear() { m_flags = 0; }
+
+  /// Clears the bits for the given enumerator.
+  void Clear(T e) { m_flags &= ~ToValueType(e); }
+
+  /// Clears all bits described by any of the given enumerators.
+  void Clear(llvm::ArrayRef<T> flags) { m_flags &= ~MergeEnumArgs(flags); }
+
+  /// Sets the bits for the given enumerator.
+  void Set(T e) { m_flags |= ToValueType(e); }
+
+  /// Sets all bits described by any of the given enumerators.
+  void Set(llvm::ArrayRef<T> flags) { m_flags |= MergeEnumArgs(flags); }
+
+  /// Tests if all bits described by the given enumerator are set.
+  /// \return True iff the respective bits are set.
+  bool Test(T e) const { return (m_flags & ToValueType(e)) != 0; }
+
+  /// Tests if all bits described by the given enumerator are not set.
+  /// \return True iff the respective bits are not set.
+  bool IsClear(T e) const { return !Test(e); }
+
+  /// Returns true iff every bit that belongs to one of the passed enumerators
+  /// is set.
+  bool AllSet(llvm::ArrayRef<T> flags) const {
+    ValueType mask = MergeEnumArgs(flags);
+    return (m_flags & mask) == mask;
+  }
+
+  /// Returns true iff at least one bit that belongs to one of the passed
+  /// enumerators is set.
+  bool AnySet(llvm::ArrayRef<T> flags) const {
+    return m_flags & MergeEnumArgs(flags);
+  }
+
+  /// Returns true iff every bit that belongs to one of the passed
+  /// enumerators is set.
+  bool AllClear(llvm::ArrayRef<T> flags) const {
+    return (m_flags & MergeEnumArgs(flags)) == 0;
+  }
+
+  /// Returns true iff at least one bit that belongs to one of the passed
+  /// enumerators is not set.
+  bool AnyClear(llvm::ArrayRef<T> flags) const {
+    ValueType mask = MergeEnumArgs(flags);
+    return (m_flags & mask) != mask;
+  }
+
+  /// Returns the internal integer storage that is used to store the flag bits.
+  /// All bits of the set enumerators are just bitwise or'd into this storage
+  /// integer.
+  /// \note This function is not using the enum type and can't do any type
+  /// checking. It only exists to implement legacy interfaces from the SB API
+  /// and should not be used anywhere else.
+  ValueType GetRawEncoding() const { return m_flags; }
+
+  /// Sets the internal integer storage that is used to store the flag bits
+  /// to the given value. The passed value should be bitwise or'd enumerators
+  /// of the respective enum of this EnumFlags specialization.
+  /// \note This function is not using the enum type and can't do any type
+  /// checking. It only exists to implement legacy interfaces from the SB API
+  /// and should not be used anywhere else.
+  void SetFromRawEncoding(ValueType t) { m_flags = t; }
+
+private:
+  /// The integer storage in which the actual
+  ValueType m_flags = 0;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_UTILITY_ENUMFLAGS_H

lldb/source/API/SBLaunchInfo.cpp

 private:
   Environment::Envp m_envp;
 };
 
 SBLaunchInfo::SBLaunchInfo(const char **argv)
     : m_opaque_sp(new SBLaunchInfoImpl()) {
   LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const char **), argv);
 
-  m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR);
+  m_opaque_sp->GetFlags().Set({eLaunchFlagDebug, eLaunchFlagDisableASLR});
   if (argv && argv[0])
     m_opaque_sp->GetArguments().SetArguments(argv);
 }
 
 SBLaunchInfo::SBLaunchInfo(const SBLaunchInfo &rhs) {
   LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const lldb::SBLaunchInfo &), rhs);
 
   m_opaque_sp = rhs.m_opaque_sp;
LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *),
                      working_dir);
 
   m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir));
 }
 
 uint32_t SBLaunchInfo::GetLaunchFlags() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetLaunchFlags);
 
-  return m_opaque_sp->GetFlags().Get();
+  return m_opaque_sp->GetFlags().GetRawEncoding();
 }
 
 void SBLaunchInfo::SetLaunchFlags(uint32_t flags) {
   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t), flags);
 
-  m_opaque_sp->GetFlags().Reset(flags);
+  m_opaque_sp->GetFlags().SetFromRawEncoding(flags);
 }
 
 const char *SBLaunchInfo::GetProcessPluginName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetProcessPluginName);
 
   return m_opaque_sp->GetProcessPluginName();
 }
 

lldb/source/DataFormatters/ValueObjectPrinter.cpp

if (m_valobj->IsSynthetic()) {
       if (m_options.m_use_synthetic) {
         ValueObject *synthetic = m_valobj->GetSyntheticValue().get();
         if (synthetic)
           m_valobj = synthetic;
       }
     }
   }
   m_compiler_type = m_valobj->GetCompilerType();
-  m_type_flags = m_compiler_type.GetTypeInfo();
+  m_type_flags.SetFromRawEncoding(m_compiler_type.GetTypeInfo());
   return true;
 }
 
 const char *ValueObjectPrinter::GetDescriptionForDisplay() {
   const char *str = m_valobj->GetObjectDescription();
   if (!str)
     str = m_valobj->GetSummaryAsCString();
   if (!str)

lldb/source/Host/common/ProcessLaunchInfo.cpp

 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 
 // ProcessLaunchInfo member functions
 
 ProcessLaunchInfo::ProcessLaunchInfo()
-    : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(0),
-      m_file_actions(), m_pty(new PseudoTerminal), m_resume_count(0),
-      m_monitor_callback(nullptr), m_monitor_callback_baton(nullptr),
-      m_monitor_signals(false), m_listener_sp(), m_hijack_listener_sp() {}
+    : ProcessInfo(), m_working_dir(), m_plugin_name(), m_file_actions(),
+      m_pty(new PseudoTerminal), m_resume_count(0), m_monitor_callback(nullptr),
+      m_monitor_callback_baton(nullptr), m_monitor_signals(false),
+      m_listener_sp(), m_hijack_listener_sp() {}
 
 ProcessLaunchInfo::ProcessLaunchInfo(const FileSpec &stdin_file_spec,
                                      const FileSpec &stdout_file_spec,
                                      const FileSpec &stderr_file_spec,
                                      const FileSpec &working_directory,
                                      uint32_t launch_flags)
-    : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(launch_flags),
-      m_file_actions(), m_pty(new PseudoTerminal), m_resume_count(0),
-      m_monitor_callback(nullptr), m_monitor_callback_baton(nullptr),
-      m_monitor_signals(false), m_listener_sp(), m_hijack_listener_sp() {
+    : ProcessInfo(), m_working_dir(), m_plugin_name(), m_file_actions(),
+      m_pty(new PseudoTerminal), m_resume_count(0), m_monitor_callback(nullptr),
+      m_monitor_callback_baton(nullptr), m_monitor_signals(false),
+      m_listener_sp(), m_hijack_listener_sp() {
+  m_flags.SetFromRawEncoding(launch_flags);
   if (stdin_file_spec) {
     FileAction file_action;
     const bool read = true;
     const bool write = false;
     if (file_action.Open(STDIN_FILENO, stdin_file_spec, read, write))
       AppendFileAction(file_action);
   }
   if (stdout_file_spec) {

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 // Process Control
 Status ProcessGDBRemote::DoLaunch(lldb_private::Module *exe_module,
                                   ProcessLaunchInfo &launch_info) {
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
   Status error;
 
   LLDB_LOGF(log, "ProcessGDBRemote::%s() entered", __FUNCTION__);
 
-  uint32_t launch_flags = launch_info.GetFlags().Get();
+  EnumFlags<LaunchFlags> launch_flags = launch_info.GetFlags();
   FileSpec stdin_file_spec{};
   FileSpec stdout_file_spec{};
   FileSpec stderr_file_spec{};
   FileSpec working_dir = launch_info.GetWorkingDirectory();
 
   const FileAction *file_action;
   file_action = launch_info.GetFileActionForFD(STDIN_FILENO);
   if (file_action) {
if (stdin_file_spec || stdout_file_spec || stderr_file_spec)
                 stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
                 stderr_file_spec ? stderr_file_spec.GetCString() : "<null>");
     else
       LLDB_LOGF(log,
                 "ProcessGDBRemote::%s no STDIO paths given via launch_info",
                 __FUNCTION__);
   }
 
-  const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
+  const bool disable_stdio = launch_flags.Test(eLaunchFlagDisableSTDIO);
   if (stdin_file_spec || disable_stdio) {
     // the inferior will be reading stdin from the specified file or stdio is
     // completely disabled
     m_stdin_forward = false;
   } else {
     m_stdin_forward = true;
   }
 
   //  ::LogSetBitMask (GDBR_LOG_DEFAULT);
   //  ::LogSetOptions (LLDB_LOG_OPTION_THREADSAFE |
   //  LLDB_LOG_OPTION_PREPEND_TIMESTAMP |
   //  LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD);
   //  ::LogSetLogFile ("/dev/stdout");
 
   ObjectFile *object_file = exe_module->GetObjectFile();
   if (object_file) {
     error = EstablishConnectionIfNeeded(launch_info);
     if (error.Success()) {
       PseudoTerminal pty;
-      const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
 
       PlatformSP platform_sp(GetTarget().GetPlatform());
       if (disable_stdio) {
         // set to /dev/null unless redirected to a file above
         if (!stdin_file_spec)
           stdin_file_spec.SetFile(FileSystem::DEV_NULL,
                                   FileSpec::Style::native);
         if (!stdout_file_spec)
if (error.Success()) {
 
       if (stdin_file_spec)
         m_gdb_comm.SetSTDIN(stdin_file_spec);
       if (stdout_file_spec)
         m_gdb_comm.SetSTDOUT(stdout_file_spec);
       if (stderr_file_spec)
         m_gdb_comm.SetSTDERR(stderr_file_spec);
 
-      m_gdb_comm.SetDisableASLR(launch_flags & eLaunchFlagDisableASLR);
-      m_gdb_comm.SetDetachOnError(launch_flags & eLaunchFlagDetachOnError);
+      m_gdb_comm.SetDisableASLR(launch_flags.Test(eLaunchFlagDisableASLR));
+      m_gdb_comm.SetDetachOnError(launch_flags.Test(eLaunchFlagDetachOnError));
 
       m_gdb_comm.SendLaunchArchPacket(
           GetTarget().GetArchitecture().GetArchitectureName());
 
       const char *launch_event_data = launch_info.GetLaunchEventData();
       if (launch_event_data != nullptr && *launch_event_data != '\0')
         m_gdb_comm.SendLaunchEventDataPacket(launch_event_data);
 

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

 }
 
 Status StructuredDataDarwinLog::FilterLaunchInfo(ProcessLaunchInfo &launch_info,
                                                  Target *target) {
   Status error;
 
   // If we're not debugging this launched process, there's nothing for us to do
   // here.
-  if (!launch_info.GetFlags().AnySet(eLaunchFlagDebug))
+  if (!launch_info.GetFlags().Test(eLaunchFlagDebug))
     return error;
 
   // Darwin os_log() support automatically adds debug-level and info-level
   // messages when a debugger is attached to a process.  However, with
   // integrated support for debugging built into the command-line LLDB, the
   // user may specifically set to *not* include debug-level and info-level
   // content.  When the user is using the integrated log support, we want to
   // put the kabosh on that automatic adding of info and debug level. This is

lldb/tools/lldb-server/lldb-gdbserver.cpp

if (end_p &&
     handle_attach_to_pid(gdb_server, static_cast<lldb::pid_t>(pid));
   else
     handle_attach_to_process_name(gdb_server, attach_target);
 }
 
 void handle_launch(GDBRemoteCommunicationServerLLGS &gdb_server,
                    llvm::ArrayRef<llvm::StringRef> Arguments) {
   ProcessLaunchInfo info;
-  info.GetFlags().Set(eLaunchFlagStopAtEntry | eLaunchFlagDebug |
-                      eLaunchFlagDisableASLR);
+  info.GetFlags().Set(
+      {eLaunchFlagStopAtEntry, eLaunchFlagDebug, eLaunchFlagDisableASLR});
   info.SetArguments(Args(Arguments), true);
 
   llvm::SmallString<64> cwd;
   if (std::error_code ec = llvm::sys::fs::current_path(cwd)) {
     llvm::errs() << "Error getting current directory: " << ec.message() << "\n";
     exit(1);
   }
   FileSpec cwd_spec(cwd);

lldb/unittests/Host/ProcessLaunchInfoTest.cpp

ProcessLaunchInfo Info(FileSpec("/stdin"), FileSpec("/stdout"),
                          eLaunchFlagStopAtEntry);
   EXPECT_EQ(FileSpec("/stdin"),
             Info.GetFileActionForFD(STDIN_FILENO)->GetFileSpec());
   EXPECT_EQ(FileSpec("/stdout"),
             Info.GetFileActionForFD(STDOUT_FILENO)->GetFileSpec());
   EXPECT_EQ(FileSpec("/stderr"),
             Info.GetFileActionForFD(STDERR_FILENO)->GetFileSpec());
   EXPECT_EQ(FileSpec("/wd"), Info.GetWorkingDirectory());
-  EXPECT_EQ(eLaunchFlagStopAtEntry, Info.GetFlags().Get());
+  EXPECT_TRUE(Info.GetFlags().Test(eLaunchFlagStopAtEntry));
 }

lldb/unittests/Utility/CMakeLists.txt

 add_lldb_unittest(UtilityTests
   AnsiTerminalTest.cpp
   ArgsTest.cpp
   OptionsWithRawTest.cpp
   ArchSpecTest.cpp
   BroadcasterTest.cpp
   ConstStringTest.cpp
   CompletionRequestTest.cpp
   DataExtractorTest.cpp
+  EnumFlagsTest.cpp
   EnvironmentTest.cpp
   EventTest.cpp
   FileSpecTest.cpp
   FlagsTest.cpp
   ListenerTest.cpp
   LogTest.cpp
   NameMatchesTest.cpp
   PredicateTest.cpp

lldb/unittests/Utility/EnumFlagsTest.cpp

+//===-- EnumFlagsTest.cpp -------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "lldb/Utility/EnumFlags.h"
+
+using namespace lldb_private;
+
+enum DummyFlags {
+  eFlag0 = 1 << 0,
+  eFlag1 = 1 << 1,
+  eFlag2 = 1 << 4,
+};
+
+TEST(EnumFlags, DefaultConstructor) {
+  EnumFlags<DummyFlags> flags;
+  EXPECT_FALSE(flags.Test(eFlag0));
+  EXPECT_FALSE(flags.Test(eFlag1));
+  EXPECT_FALSE(flags.Test(eFlag2));
+}
+
+TEST(EnumFlags, ListConstructor) {
+  EnumFlags<DummyFlags> flags({eFlag0, eFlag1});
+  EXPECT_TRUE(flags.Test(eFlag0));
+  EXPECT_TRUE(flags.Test(eFlag1));
+  EXPECT_FALSE(flags.Test(eFlag2));
+}
+
+TEST(EnumFlags, Set) {
+  EnumFlags<DummyFlags> flags;
+
+  flags.Set(eFlag0);
+  EXPECT_TRUE(flags.Test(eFlag0));
+  EXPECT_FALSE(flags.Test(eFlag1));
+  EXPECT_FALSE(flags.Test(eFlag2));
+
+  flags.Set(eFlag1);
+  EXPECT_TRUE(flags.Test(eFlag0));
+  EXPECT_TRUE(flags.Test(eFlag1));
+  EXPECT_FALSE(flags.Test(eFlag2));
+}
+
+TEST(EnumFlags, SetSeveral) {
+  EnumFlags<DummyFlags> flags;
+
+  flags.Set({eFlag0, eFlag1});
+  EXPECT_TRUE(flags.Test(eFlag0));
+  EXPECT_TRUE(flags.Test(eFlag1));
+  EXPECT_FALSE(flags.Test(eFlag2));
+
+  flags.Set({eFlag1, eFlag2});
+  EXPECT_TRUE(flags.Test(eFlag0));
+  EXPECT_TRUE(flags.Test(eFlag1));
+  EXPECT_TRUE(flags.Test(eFlag2));
+}
+
+TEST(EnumFlags, Clear) {
+  EnumFlags<DummyFlags> flags({eFlag0, eFlag1});
+
+  flags.Clear(eFlag0);
+  EXPECT_FALSE(flags.Test(eFlag0));
+  EXPECT_TRUE(flags.Test(eFlag1));
+  EXPECT_FALSE(flags.Test(eFlag2));
+
+  flags.Clear(eFlag1);
+  EXPECT_FALSE(flags.Test(eFlag0));
+  EXPECT_FALSE(flags.Test(eFlag1));
+  EXPECT_FALSE(flags.Test(eFlag2));
+}
+
+TEST(EnumFlags, ClearSeveral) {
+  EnumFlags<DummyFlags> flags({eFlag0, eFlag1, eFlag2});
+
+  flags.Clear({eFlag0, eFlag1});
+  EXPECT_FALSE(flags.Test(eFlag0));
+  EXPECT_FALSE(flags.Test(eFlag1));
+  EXPECT_TRUE(flags.Test(eFlag2));
+
+  flags.Clear({eFlag1, eFlag2});
+  EXPECT_FALSE(flags.Test(eFlag0));
+  EXPECT_FALSE(flags.Test(eFlag1));
+  EXPECT_FALSE(flags.Test(eFlag2));
+}
+
+TEST(EnumFlags, IsClear) {
+  EnumFlags<DummyFlags> flags;
+
+  flags.Set(eFlag0);
+  EXPECT_FALSE(flags.IsClear(eFlag0));
+  EXPECT_TRUE(flags.IsClear(eFlag1));
+  EXPECT_TRUE(flags.IsClear(eFlag2));
+
+  flags.Set(eFlag1);
+  EXPECT_FALSE(flags.IsClear(eFlag0));
+  EXPECT_FALSE(flags.IsClear(eFlag1));
+  EXPECT_TRUE(flags.IsClear(eFlag2));
+}
+
+TEST(EnumFlags, AllSet) {
+  EnumFlags<DummyFlags> flags({eFlag0, eFlag2});
+  EXPECT_TRUE(flags.AllSet({eFlag0, eFlag2}));
+  EXPECT_TRUE(flags.AllSet({eFlag0}));
+  EXPECT_FALSE(flags.AllSet({eFlag1}));
+  EXPECT_FALSE(flags.AllSet({eFlag0, eFlag1}));
+  EXPECT_FALSE(flags.AllSet({eFlag2, eFlag1, eFlag0}));
+}
+
+TEST(EnumFlags, AnySet) {
+  EnumFlags<DummyFlags> flags({eFlag0, eFlag2});
+  EXPECT_TRUE(flags.AnySet({eFlag0, eFlag2}));
+  EXPECT_TRUE(flags.AnySet({eFlag0}));
+  EXPECT_FALSE(flags.AnySet({eFlag1}));
+  EXPECT_TRUE(flags.AnySet({eFlag0, eFlag1}));
+  EXPECT_TRUE(flags.AnySet({eFlag2, eFlag1, eFlag0}));
+}
+
+TEST(EnumFlags, AllClear) {
+  EnumFlags<DummyFlags> flags({eFlag0, eFlag2});
+  EXPECT_TRUE(flags.AllSet({eFlag0, eFlag2}));
+  EXPECT_TRUE(flags.AllSet({eFlag0}));
+  EXPECT_FALSE(flags.AllSet({eFlag1}));
+  EXPECT_FALSE(flags.AllSet({eFlag0, eFlag1}));
+  EXPECT_FALSE(flags.AllSet({eFlag2, eFlag1, eFlag0}));
+}
+
+TEST(EnumFlags, AnyClear) {
+  EnumFlags<DummyFlags> flags({eFlag0, eFlag2});
+  EXPECT_TRUE(flags.AnySet({eFlag0, eFlag2}));
+  EXPECT_TRUE(flags.AnySet({eFlag0}));
+  EXPECT_FALSE(flags.AnySet({eFlag1}));
+  EXPECT_TRUE(flags.AnySet({eFlag0, eFlag1}));
+  EXPECT_TRUE(flags.AnySet({eFlag2, eFlag1, eFlag0}));
+}
+
+TEST(EnumFlags, GetRawEncoding) {
+  EnumFlags<DummyFlags> flags;
+  EXPECT_EQ(flags.GetRawEncoding(), 0U);
+  flags.Set({eFlag0, eFlag2});
+  EXPECT_EQ(flags.GetRawEncoding(), static_cast<unsigned>(eFlag0 | eFlag2));
+  flags.Set(eFlag1);
+  EXPECT_EQ(flags.GetRawEncoding(),
+            static_cast<unsigned>(eFlag0 | eFlag1 | eFlag2));
+}
+
+TEST(EnumFlags, SetFromRawEncoding) {
+  EnumFlags<DummyFlags> flags;
+  flags.SetFromRawEncoding(eFlag0 | eFlag1);
+  EXPECT_EQ(flags.GetRawEncoding(), static_cast<unsigned>(eFlag0 | eFlag1));
+  flags.SetFromRawEncoding(eFlag0);
+  EXPECT_TRUE(flags.Test(eFlag0));
+}
+
+enum class Scoped { Flag0 = (1 << 0), Flag1 = (1 << 1), Flag2 = (1 << 3) };
+
+TEST(EnumFlags, ScopedEnum) {
+  // Call all functions and test some basic functionality with a scoped enum.
+  EnumFlags<Scoped> flags;
+  flags.Set(Scoped::Flag0);
+  EXPECT_TRUE(flags.Test(Scoped::Flag0));
+  EXPECT_FALSE(flags.Test(Scoped::Flag1));
+  EXPECT_FALSE(flags.Test(Scoped::Flag2));
+  EXPECT_TRUE(flags.IsClear(Scoped::Flag2));
+
+  flags.Set({Scoped::Flag1, Scoped::Flag0});
+  EXPECT_TRUE(flags.Test(Scoped::Flag0));
+  EXPECT_TRUE(flags.Test(Scoped::Flag1));
+  EXPECT_FALSE(flags.Test(Scoped::Flag2));
+
+  flags.Clear(Scoped::Flag0);
+  EXPECT_FALSE(flags.Test(Scoped::Flag0));
+  EXPECT_TRUE(flags.Test(Scoped::Flag1));
+  EXPECT_FALSE(flags.Test(Scoped::Flag2));
+
+  flags.Clear({Scoped::Flag0, Scoped::Flag2});
+  EXPECT_FALSE(flags.Test(Scoped::Flag0));
+  EXPECT_TRUE(flags.Test(Scoped::Flag1));
+  EXPECT_FALSE(flags.Test(Scoped::Flag2));
+
+  EXPECT_TRUE(flags.AllSet({Scoped::Flag1}));
+  EXPECT_FALSE(flags.AllSet({Scoped::Flag1, Scoped::Flag2}));
+
+  EXPECT_TRUE(flags.AnySet({Scoped::Flag1}));
+  EXPECT_FALSE(flags.AnySet({Scoped::Flag0, Scoped::Flag2}));
+
+  EXPECT_FALSE(flags.AllClear({Scoped::Flag1}));
+  EXPECT_TRUE(flags.AllClear({Scoped::Flag0, Scoped::Flag2}));
+
+  EXPECT_FALSE(flags.AnyClear({Scoped::Flag1}));
+  EXPECT_TRUE(flags.AnyClear({Scoped::Flag0, Scoped::Flag2}));
+
+  EnumFlags<Scoped> flags2({Scoped::Flag0, Scoped::Flag1});
+  EXPECT_TRUE(flags2.Test(Scoped::Flag0));
+}