Merge branch 'trunk' into test-call-returning-facet-value

Author: danakj

.clang-format

@@ -17,7 +17,9 @@ SpaceBeforeParens: ControlStatementsExceptControlMacros
 IfMacros:
   [
     'CARBON_DEFINE_RAW_ENUM_CLASS',
-    'CARBON_DEFINE_RAW_ENUM_CLASS_NO_NAMES',
+    'CARBON_DEFINE_ENUM_CLASS_NAMES',
+    'CARBON_DEFINE_RAW_ENUM_MASK',
+    'CARBON_DEFINE_ENUM_MASK_NAMES',
     'CARBON_KIND_SWITCH',
   ]
 StatementMacros: ['ABSTRACT']

.clang-tidy

@@ -22,6 +22,7 @@ Checks:
   - '-misc-const-correctness'
   - '-misc-include-cleaner'
   - '-misc-use-anonymous-namespace'
+  - '-modernize-deprecated-headers'
   - '-modernize-return-braced-init-list'
   - '-modernize-use-default-member-init'
   - '-modernize-use-integer-sign-comparison'

.github/workflows/clang_tidy.yaml

@@ -8,8 +8,7 @@ on:
   push:
     branches: [trunk, action-test]
   pull_request:
-  # TODO: Don't run in merge_group until we're ready to replace clang-tidy.
-  # merge_group:
+  merge_group:
 
 permissions:
   contents: read # For actions/checkout.

.github/workflows/clangd_tidy.yaml

@@ -159,6 +159,27 @@ cc_test(
     ],
 )
 
+cc_library(
+    name = "enum_mask_base",
+    hdrs = ["enum_mask_base.h"],
+    deps = [
+        ":enum_base",
+        "@llvm-project//llvm:Support",
+    ],
+)
+
+cc_test(
+    name = "enum_mask_base_test",
+    size = "small",
+    srcs = ["enum_mask_base_test.cpp"],
+    deps = [
+        ":enum_mask_base",
+        ":raw_string_ostream",
+        "//testing/base:gtest_main",
+        "@googletest//:gtest",
+    ],
+)
+
 cc_library(
     name = "error",
     hdrs = ["error.h"],

common/BUILD

@@ -5,6 +5,7 @@
 #ifndef CARBON_COMMON_ENUM_BASE_H_
 #define CARBON_COMMON_ENUM_BASE_H_
 
+#include <compare>
 #include <type_traits>
 
 #include "common/ostream.h"
@@ -53,7 +54,7 @@ namespace Carbon::Internal {
 //
 // In `my_kind.cpp`:
 //   ```
-//   CARBON_DEFINE_ENUM_CLASS_NAMES(MyKind) = {
+//   CARBON_DEFINE_ENUM_CLASS_NAMES(MyKind) {
 //   #define CARBON_MY_KIND(Name) CARBON_ENUM_CLASS_NAME_STRING(Name)
 //   #include ".../my_kind.def"
 //   };
@@ -122,22 +123,26 @@ class EnumBase : public Printable<DerivedT> {
   // function.
   //
   // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr operator RawEnumType() const { return value_; }
+  explicit(false) constexpr operator RawEnumType() const { return value_; }
 
   // Conversion to bool is deleted to prevent direct use in an `if` condition
   // instead of comparing with another value.
   explicit operator bool() const = delete;
 
   // Returns the name of this value.
-  //
-  // This method will be automatically defined using the static `names` string
-  // table in the base class, which is in turn will be populated for each
-  // derived type using the macro helpers in this file.
   auto name() const -> llvm::StringRef { return Names[AsInt()]; }
 
   // Prints this value using its name.
   auto Print(llvm::raw_ostream& out) const -> void { out << name(); }
 
+  // Don't support comparison of enums by default.
+  friend auto operator<(DerivedT lhs, DerivedT rhs) -> bool = delete;
+  friend auto operator<=(DerivedT lhs, DerivedT rhs) -> bool = delete;
+  friend auto operator>(DerivedT lhs, DerivedT rhs) -> bool = delete;
+  friend auto operator>=(DerivedT lhs, DerivedT rhs) -> bool = delete;
+  friend auto operator<=>(DerivedT lhs, DerivedT rhs)
+      -> std::partial_ordering = delete;
+
  protected:
   // The default constructor is explicitly defaulted (and constexpr) as a
   // protected constructor to allow derived classes to be constructed but not
@@ -165,42 +170,38 @@ class EnumBase : public Printable<DerivedT> {
   }
 
  private:
+  template <typename MaskDerivedT, typename MaskEnumT,
+            const llvm::StringLiteral MaskNames[]>
+  friend class EnumMaskBase;
+
   RawEnumType value_;
 };
 
 }  // namespace Carbon::Internal
 
-// For use when multiple enums use the same list of names.
-#define CARBON_DEFINE_RAW_ENUM_CLASS_NO_NAMES(EnumClassName, UnderlyingType) \
-  namespace Internal {                                                       \
-  enum class EnumClassName##RawEnum : UnderlyingType;                        \
-  }                                                                          \
-  enum class Internal::EnumClassName##RawEnum : UnderlyingType
-
 // Use this before defining a class that derives from `EnumBase` to begin the
 // definition of the raw `enum class`. It should be followed by the body of that
 // raw enum class.
 #define CARBON_DEFINE_RAW_ENUM_CLASS(EnumClassName, UnderlyingType) \
   namespace Internal {                                              \
-  extern const llvm::StringLiteral EnumClassName##Names[];          \
+  struct EnumClassName##Data {                                      \
+    static const llvm::StringLiteral Names[];                       \
+    enum class RawEnum : UnderlyingType;                            \
+  };                                                                \
   }                                                                 \
-  CARBON_DEFINE_RAW_ENUM_CLASS_NO_NAMES(EnumClassName, UnderlyingType)
+  enum class Internal::EnumClassName##Data::RawEnum : UnderlyingType
 
-// In CARBON_DEFINE_RAW_ENUM_CLASS block, use this to generate each enumerator.
+// In the `CARBON_DEFINE_RAW_ENUM_CLASS` block, use this to generate each
+// enumerator.
 #define CARBON_RAW_ENUM_ENUMERATOR(Name) Name,
 
 // Use this to compute the `Internal::EnumBase` specialization for a Carbon enum
 // class. It both computes the name of the raw enum and ensures all the
 // namespaces are correct.
-#define CARBON_ENUM_BASE(EnumClassName) \
-  CARBON_ENUM_BASE_CRTP(EnumClassName, EnumClassName, EnumClassName)
-// This variant handles the case where the external name for the Carbon enum is
-// not the same as the name by which we refer to it from this context.
-#define CARBON_ENUM_BASE_CRTP(EnumClassName, LocalTypeNameForEnumClass, \
-                              EnumClassNameForNames)                    \
-  ::Carbon::Internal::EnumBase<LocalTypeNameForEnumClass,               \
-                               Internal::EnumClassName##RawEnum,        \
-                               Internal::EnumClassNameForNames##Names>
+#define CARBON_ENUM_BASE(EnumClassName)                                \
+  ::Carbon::Internal::EnumBase<EnumClassName,                          \
+                               Internal::EnumClassName##Data::RawEnum, \
+                               Internal::EnumClassName##Data::Names>
 
 // Use this within the Carbon enum class body to generate named constant
 // declarations for each value.
@@ -212,24 +213,14 @@ class EnumBase : public Printable<DerivedT> {
   constexpr EnumClassName EnumClassName::Name =              \
       EnumClassName::Make(RawEnumType::Name);
 
-// Alternatively, use this within the Carbon enum class body to declare and
-// define each named constant. Due to type completeness constraints, this will
-// only work if the enum-like class is templated.
-//
-// This requires the template to have a member named `Base` that names the
-// `EnumBase` base class.
-#define CARBON_INLINE_ENUM_CONSTANT_DEFINITION(Name)     \
-  static constexpr const typename Base::EnumType& Name = \
-      Base::Make(Base::RawEnumType::Name);
-
 // Use this in the `.cpp` file for an enum class to start the definition of the
 // constant names array for each enumerator. It is followed by the desired
 // constant initializer.
 //
 // `clang-format` has a bug with spacing around `->` returns in macros. See
 // https://bugs.llvm.org/show_bug.cgi?id=48320 for details.
 #define CARBON_DEFINE_ENUM_CLASS_NAMES(EnumClassName) \
-  constexpr llvm::StringLiteral Internal::EnumClassName##Names[]
+  constexpr llvm::StringLiteral Internal::EnumClassName##Data::Names[] =
 
 // Use this within the names array initializer to generate a string for each
 // name.

common/enum_base.h

@@ -30,7 +30,7 @@ class TestKind : public CARBON_ENUM_BASE(TestKind) {
   CARBON_ENUM_CONSTANT_DEFINITION(TestKind, Name)
 #include "common/enum_base_test.def"
 
-CARBON_DEFINE_ENUM_CLASS_NAMES(TestKind) = {
+CARBON_DEFINE_ENUM_CLASS_NAMES(TestKind) {
 #define CARBON_ENUM_BASE_TEST_KIND(Name) CARBON_ENUM_CLASS_NAME_STRING(Name)
 #include "common/enum_base_test.def"
 };
@@ -79,23 +79,15 @@ TEST(EnumBaseTest, Switch) {
 TEST(EnumBaseTest, Comparison) {
   TestKind kind = TestKind::Beep;
 
-  // Make sure all the different comparisons work, and also to work with
+  // Make sure all the different comparisons work, and also work with
   // GoogleTest expectations.
   EXPECT_EQ(TestKind::Beep, kind);
   EXPECT_NE(TestKind::Boop, kind);
-  EXPECT_LT(kind, TestKind::Boop);
-  EXPECT_GT(TestKind::Burr, kind);
-  EXPECT_LE(kind, TestKind::Beep);
-  EXPECT_GE(TestKind::Beep, kind);
 
   // These should also all be constexpr.
   constexpr TestKind Kind2 = TestKind::Beep;
   static_assert(Kind2 == TestKind::Beep);
   static_assert(Kind2 != TestKind::Boop);
-  static_assert(Kind2 < TestKind::Boop);
-  static_assert(!(Kind2 > TestKind::Burr));
-  static_assert(Kind2 <= TestKind::Beep);
-  static_assert(!(Kind2 >= TestKind::Burr));
 }
 
 TEST(EnumBaseTest, IntConversion) {