[ADT] Alternative way to declare enum type as bitmask

[sepavloff]

Summary

If an enumeration represents set of bit flags, using the macro
LLVM_MARK_AS_BITMASK_ENUM can make operations with such enumeration more
convenient. It however brings problems if the enumeration is non-scoped.
As the macro adds an item LLVM_BITMASK_LARGEST_ENUMERATOR to the
enumeration type, only one such type may be declared as bitmask. This
problem could be solved by convertion of the enumeration to scoped, but
it requires static_casts in new places and the convenience can be
eliminated.

This change introduces a new macro LLVM_DECLARE_ENUM_AS_BITMASK, which
allows non-invasive convertion of an enumeration into bitmask. It
provides specialization to trait classes, which previously were built
based on presence of LLVM_BITMASK_LARGEST_ENUMERATOR in the enumeration.
The macro must be specified in global or llvm namespace because the
trait classes are declared in llvm namespace.

[arsenm]

LGTM. I reproduced the same thing, except I was also trying to eliminate the existing LLVM_MARK_AS_BITMASK_ENUM method which was the tricky part

[sepavloff]

Thanks!

llvm/include/llvm/ADT/BitmaskEnum.h

 ///
 /// The parameter to LLVM_MARK_AS_BITMASK_ENUM should be the largest individual
 /// value in your enum.
 ///
 /// All of the enum's values must be non-negative.
 #define LLVM_MARK_AS_BITMASK_ENUM(LargestValue)                                \
   LLVM_BITMASK_LARGEST_ENUMERATOR = LargestValue
 
+/// LLVM_DECLARE_ENUM_AS_BITMASK can be used to declare an enum type as a bit
+/// set, so that bitwise operation on such enum does not require static_cast.
+///
+/// \code
+///   enum MyEnum { E1 = 1, E2 = 2, E3 = 4, E4 = 8 };
+///   LLVM_DECLARE_ENUM_AS_BITMASK(MyEnum, E4);
+///
+///   void Foo() {
+///     MyEnum A = (E1 | E2) & E3 ^ ~E4; // No static_cast
+///   }
+/// \endcode
+///
+/// The second parameter to LLVM_DECLARE_ENUM_AS_BITMASK specifies the largest
+/// bit value of the enum type.
+///
+/// LLVM_DECLARE_ENUM_AS_BITMASK should be used in global or llvm namespace.
+///
+/// This a non-intrusive alternative for LLVM_MARK_AS_BITMASK_ENUM. It allows
+/// declaring more than one non-scoped enumerations as bitmask types in the same
+/// scope. Otherwise it provides the same functionality as
+/// LLVM_MARK_AS_BITMASK_ENUM.
+#define LLVM_DECLARE_ENUM_AS_BITMASK(Enum, LargestValue)                       \
+  template <> struct llvm::is_bitmask_enum<Enum> : std::true_type {};          \
+  template <> struct llvm::largest_bitmask_enum_bit<Enum> {                    \
+    static constexpr std::underlying_type_t<Enum> value = LargestValue;        \
+  }
+
 /// LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE() pulls the operator overloads used
 /// by LLVM_MARK_AS_BITMASK_ENUM into the current namespace.
 ///
 /// Suppose you have an enum foo::bar::MyEnum.  Before using
 /// LLVM_MARK_AS_BITMASK_ENUM on MyEnum, you must put
 /// LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE() somewhere inside namespace foo or
 /// namespace foo::bar.  This allows the relevant operator overloads to be found
 /// by ADL.

 /// LLVM_BITMASK_LARGEST_ENUMERATOR enumerator.
 template <typename E, typename Enable = void>
 struct is_bitmask_enum : std::false_type {};
 
 template <typename E>
 struct is_bitmask_enum<
     E, std::enable_if_t<sizeof(E::LLVM_BITMASK_LARGEST_ENUMERATOR) >= 0>>
     : std::true_type {};
+
+/// Trait class to determine bitmask enumeration largest bit.
+template <typename E, typename Enable = void> struct largest_bitmask_enum_bit;
+
+template <typename E>
+struct largest_bitmask_enum_bit<
+    E, std::enable_if_t<sizeof(E::LLVM_BITMASK_LARGEST_ENUMERATOR) >= 0>> {
+  using UnderlyingTy = std::underlying_type_t<E>;
+  static constexpr UnderlyingTy value =
+      static_cast<UnderlyingTy>(E::LLVM_BITMASK_LARGEST_ENUMERATOR);
+};
+
 namespace BitmaskEnumDetail {
 
 /// Get a bitmask with 1s in all places up to the high-order bit of E's largest
 /// value.
 template <typename E> constexpr std::underlying_type_t<E> Mask() {
   // On overflow, NextPowerOf2 returns zero with the type uint64_t, so
   // subtracting 1 gives us the mask with all bits set, like we want.
-  return NextPowerOf2(static_cast<std::underlying_type_t<E>>(
-             E::LLVM_BITMASK_LARGEST_ENUMERATOR)) -
-         1;
+  return NextPowerOf2(largest_bitmask_enum_bit<E>::value) - 1;
 }
 
 /// Check that Val is in range for E, and return Val cast to E's underlying
 /// type.
 template <typename E> constexpr std::underlying_type_t<E> Underlying(E Val) {
   auto U = static_cast<std::underlying_type_t<E>>(Val);
   assert(U >= 0 && "Negative enum values are not allowed.");
   assert(U <= Mask<E>() && "Enum value too large (or largest val too small?)");

llvm/unittests/ADT/BitmaskEnumTest.cpp

enum Flags {
   F0 = 0,
   F1 = 1,
   F2 = 2,
   F3 = 4,
   F4 = 8,
   LLVM_MARK_AS_BITMASK_ENUM(F4)
 };
 
+static_assert(is_bitmask_enum<Flags>::value != 0);
+static_assert(largest_bitmask_enum_bit<Flags>::value == Flags::F4);
+
+enum Flags2 { V0 = 0, V1 = 1, V2 = 2, V3 = 4, V4 = 8 };
+} // namespace
+
+LLVM_DECLARE_ENUM_AS_BITMASK(Flags2, V4);
+
+static_assert(is_bitmask_enum<Flags>::value != 0);
+static_assert(largest_bitmask_enum_bit<Flags>::value == Flags::F4);
+
+namespace {
 TEST(BitmaskEnumTest, BitwiseOr) {
   Flags f = F1 | F2;
   EXPECT_EQ(3, f);
 
   f = f | F3;
   EXPECT_EQ(7, f);
+
+  Flags2 f2 = V1 | V2;
+  EXPECT_EQ(3, f2);
+
+  f2 = f2 | V3;
+  EXPECT_EQ(7, f2);
 }
 
 TEST(BitmaskEnumTest, BitwiseOrEquals) {
   Flags f = F1;
   f |= F3;
   EXPECT_EQ(5, f);
 
   // |= should return a reference to the LHS.
   f = F2;
   (f |= F3) = F1;
   EXPECT_EQ(F1, f);
+
+  Flags2 f2 = V1;
+  f2 |= V3;
+  EXPECT_EQ(5, f2);
+
+  f2 = V2;
+  (f2 |= V3) = V1;
+  EXPECT_EQ(V1, f2);
 }
 
 TEST(BitmaskEnumTest, BitwiseAnd) {
   Flags f = static_cast<Flags>(3) & F2;
   EXPECT_EQ(F2, f);
 
   f = (f | F3) & (F1 | F2 | F3);
   EXPECT_EQ(6, f);
+
+  Flags2 f2 = static_cast<Flags2>(3) & V2;
+  EXPECT_EQ(V2, f2);
+
+  f2 = (f2 | V3) & (V1 | V2 | V3);
+  EXPECT_EQ(6, f2);
 }
 
 TEST(BitmaskEnumTest, BitwiseAndEquals) {
   Flags f = F1 | F2 | F3;
   f &= F1 | F2;
   EXPECT_EQ(3, f);
 
   // &= should return a reference to the LHS.
   (f &= F1) = F3;
   EXPECT_EQ(F3, f);
+
+  Flags2 f2 = V1 | V2 | V3;
+  f2 &= V1 | V2;
+  EXPECT_EQ(3, f2);
+
+  (f2 &= V1) = V3;
+  EXPECT_EQ(V3, f2);
 }
 
 TEST(BitmaskEnumTest, BitwiseXor) {
   Flags f = (F1 | F2) ^ (F2 | F3);
   EXPECT_EQ(5, f);
 
   f = f ^ F1;
   EXPECT_EQ(4, f);
+
+  Flags2 f2 = (V1 | V2) ^ (V2 | V3);
+  EXPECT_EQ(5, f2);
+
+  f2 = f2 ^ V1;
+  EXPECT_EQ(4, f2);
 }
 
 TEST(BitmaskEnumTest, BitwiseXorEquals) {
   Flags f = (F1 | F2);
   f ^= (F2 | F4);
   EXPECT_EQ(9, f);
 
   // ^= should return a reference to the LHS.
   (f ^= F4) = F3;
   EXPECT_EQ(F3, f);
+
+  Flags2 f2 = (V1 | V2);
+  f2 ^= (V2 | V4);
+  EXPECT_EQ(9, f2);
+
+  (f2 ^= V4) = V3;
+  EXPECT_EQ(V3, f2);
 }
 
 TEST(BitmaskEnumTest, ConstantExpression) {
   constexpr Flags f1 = ~F1;
   constexpr Flags f2 = F1 | F2;
   constexpr Flags f3 = F1 & F2;
   constexpr Flags f4 = F1 ^ F2;
   EXPECT_EQ(f1, ~F1);
   EXPECT_EQ(f2, F1 | F2);
   EXPECT_EQ(f3, F1 & F2);
   EXPECT_EQ(f4, F1 ^ F2);
+
+  constexpr Flags2 f21 = ~V1;
+  constexpr Flags2 f22 = V1 | V2;
+  constexpr Flags2 f23 = V1 & V2;
+  constexpr Flags2 f24 = V1 ^ V2;
+  EXPECT_EQ(f21, ~V1);
+  EXPECT_EQ(f22, V1 | V2);
+  EXPECT_EQ(f23, V1 & V2);
+  EXPECT_EQ(f24, V1 ^ V2);
 }
 
 TEST(BitmaskEnumTest, BitwiseNot) {
   Flags f = ~F1;
   EXPECT_EQ(14, f); // Largest value for f is 15.
   EXPECT_EQ(15, ~F0);
+
+  Flags2 f2 = ~V1;
+  EXPECT_EQ(14, f2);
+  EXPECT_EQ(15, ~V0);
 }
 
 enum class FlagsClass {
   F0 = 0,
   F1 = 1,
   F2 = 2,
   F3 = 4,
   LLVM_MARK_AS_BITMASK_ENUM(F3)