Merge pull request #30086 from CodaFi/constexpert-mode

[NFC] Mark The OptionSet API constexpr

Author: CodaFi

include/swift/Basic/OptionSet.h

@@ -50,45 +50,46 @@ class OptionSet {
 
 public:
   /// Create an empty option set.
-  OptionSet() : Storage() { }
+  constexpr OptionSet() : Storage() {}
 
   /// Create an empty option set.
-  OptionSet(llvm::NoneType) : Storage() { }
+  constexpr OptionSet(llvm::NoneType) : Storage() {}
 
   /// Create an option set with only the given option set.
-  OptionSet(Flags flag) : Storage(static_cast<StorageType>(flag)) { }
+  constexpr OptionSet(Flags flag) : Storage(static_cast<StorageType>(flag)) {}
 
   /// Create an option set from raw storage.
-  explicit OptionSet(StorageType storage) : Storage(storage) { }
+  explicit constexpr OptionSet(StorageType storage) : Storage(storage) {}
 
   /// Check whether an option set is non-empty.
-  explicit operator bool() const { return Storage != 0; }
+  explicit constexpr operator bool() const { return Storage != 0; }
 
   /// Explicitly convert an option set to its underlying storage.
-  explicit operator StorageType() const { return Storage; }
+  explicit constexpr operator StorageType() const { return Storage; }
 
   /// Explicitly convert an option set to intptr_t, for use in
   /// llvm::PointerIntPair.
   ///
   /// This member is not present if the underlying type is bigger than
   /// a pointer.
   template <typename T = std::intptr_t>
-  explicit operator typename std::enable_if<sizeof(StorageType) <= sizeof(T),
-      std::intptr_t>::type () const {
+  explicit constexpr
+  operator typename std::enable_if<sizeof(StorageType) <= sizeof(T),
+                                   std::intptr_t>::type() const {
     return static_cast<intptr_t>(Storage);
   }
 
   /// Retrieve the "raw" representation of this option set.
   StorageType toRaw() const { return Storage; }
-  
+
   /// Determine whether this option set contains all of the options in the
   /// given set.
-  bool contains(OptionSet set) const {
+  constexpr bool contains(OptionSet set) const {
     return !static_cast<bool>(set - *this);
   }
 
   /// Check if this option set contains the exact same options as the given set.
-  bool containsOnly(OptionSet set) const {
+  constexpr bool containsOnly(OptionSet set) const {
     return Storage == set.Storage;
   }
 
@@ -97,34 +98,34 @@ class OptionSet {
   // want '==' behavior, use 'containsOnly'.
 
   /// Produce the union of two option sets.
-  friend OptionSet operator|(OptionSet lhs, OptionSet rhs) {
+  friend constexpr OptionSet operator|(OptionSet lhs, OptionSet rhs) {
     return OptionSet(lhs.Storage | rhs.Storage);
   }
 
   /// Produce the union of two option sets.
-  friend OptionSet &operator|=(OptionSet &lhs, OptionSet rhs) {
+  friend constexpr OptionSet &operator|=(OptionSet &lhs, OptionSet rhs) {
     lhs.Storage |= rhs.Storage;
     return lhs;
- }
+  }
 
   /// Produce the intersection of two option sets.
-  friend OptionSet operator&(OptionSet lhs, OptionSet rhs) {
+  friend constexpr OptionSet operator&(OptionSet lhs, OptionSet rhs) {
     return OptionSet(lhs.Storage & rhs.Storage);
   }
 
   /// Produce the intersection of two option sets.
-  friend OptionSet &operator&=(OptionSet &lhs, OptionSet rhs) {
+  friend constexpr OptionSet &operator&=(OptionSet &lhs, OptionSet rhs) {
     lhs.Storage &= rhs.Storage;
     return lhs;
   }
 
   /// Produce the difference of two option sets.
-  friend OptionSet operator-(OptionSet lhs, OptionSet rhs) {
+  friend constexpr OptionSet operator-(OptionSet lhs, OptionSet rhs) {
     return OptionSet(lhs.Storage & ~rhs.Storage);
   }
 
   /// Produce the difference of two option sets.
-  friend OptionSet &operator-=(OptionSet &lhs, OptionSet rhs) {
+  friend constexpr OptionSet &operator-=(OptionSet &lhs, OptionSet rhs) {
     lhs.Storage &= ~rhs.Storage;
     return lhs;
   }