Migrate Type::kind() to TypeKind

PiperOrigin-RevId: 534168362

Author: jcking

base/BUILD

@@ -65,9 +65,7 @@ cc_library(
     srcs = ["kind.cc"],
     hdrs = ["kind.h"],
     deps = [
-        "@com_google_absl//absl/base",
         "@com_google_absl//absl/base:core_headers",
-        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/strings",
     ],
 )

base/internal/data.h

@@ -184,6 +184,8 @@ class HeapData /* : public Data */ {
       : metadata_and_reference_count_(static_cast<uintptr_t>(kind)
                                       << kKindShift) {}
 
+  explicit HeapData(TypeKind kind) : HeapData(TypeKindToKind(kind)) {}
+
  private:
   // Called by Arena-based memory managers to determine whether we actually need
   // our destructor called. Subclasses should override this if they want their

base/internal/type.h

@@ -45,7 +45,7 @@ class LegacyMapType;
 class ModernMapType;
 struct FieldIdFactory;
 
-template <Kind K>
+template <TypeKind K>
 class SimpleType;
 template <typename T, typename U>
 class SimpleValue;
@@ -108,7 +108,7 @@ struct TypeTraits;
   static_assert(!::std::is_abstract_v<derived>, "this must not be abstract"); \
                                                                               \
   bool derived::Is(const ::cel::Type& type) {                                 \
-    return type.kind() == ::cel::Kind::k##base &&                             \
+    return type.kind() == ::cel::TypeKind::k##base &&                         \
            ::cel::base_internal::Get##base##TypeTypeId(                       \
                static_cast<const ::cel::base##Type&>(type)) ==                \
                ::cel::internal::TypeId<derived>();                            \

base/kind.cc

@@ -16,15 +16,6 @@
 
 namespace cel {
 
-bool KindIsTypeKind(Kind kind) {
-  // Currently all Kind are valid TypeKind.
-  return true;
-}
-
-bool KindIsValueKind(Kind kind) {
-  return kind != Kind::kWrapper && kind != Kind::kDyn && kind != Kind::kAny;
-}
-
 absl::string_view KindToString(Kind kind) {
   switch (kind) {
     case Kind::kNullType:

base/kind.h

@@ -18,8 +18,7 @@
 #include <type_traits>
 
 #include "absl/base/attributes.h"
-#include "absl/base/casts.h"
-#include "absl/log/absl_check.h"
+#include "absl/base/macros.h"
 #include "absl/strings/string_view.h"
 
 namespace cel {
@@ -103,21 +102,30 @@ enum class TypeKind : std::underlying_type_t<Kind> {
       static_cast<int>(Kind::kNotForUseWithExhaustiveSwitchStatements),
 };
 
-inline Kind TypeKindToKind(TypeKind kind) { return absl::bit_cast<Kind>(kind); }
+constexpr Kind TypeKindToKind(TypeKind kind) {
+  return static_cast<Kind>(static_cast<std::underlying_type_t<TypeKind>>(kind));
+}
 
-ABSL_ATTRIBUTE_PURE_FUNCTION bool KindIsTypeKind(Kind kind);
+constexpr bool KindIsTypeKind(Kind kind ABSL_ATTRIBUTE_UNUSED) {
+  // Currently all Kind are valid TypeKind.
+  return true;
+}
 
-inline bool operator==(Kind lhs, TypeKind rhs) {
+constexpr bool operator==(Kind lhs, TypeKind rhs) {
   return lhs == TypeKindToKind(rhs);
 }
 
-inline bool operator==(TypeKind lhs, Kind rhs) {
+constexpr bool operator==(TypeKind lhs, Kind rhs) {
   return TypeKindToKind(lhs) == rhs;
 }
 
-inline bool operator!=(Kind lhs, TypeKind rhs) { return !operator==(lhs, rhs); }
+constexpr bool operator!=(Kind lhs, TypeKind rhs) {
+  return !operator==(lhs, rhs);
+}
 
-inline bool operator!=(TypeKind lhs, Kind rhs) { return !operator==(lhs, rhs); }
+constexpr bool operator!=(TypeKind lhs, Kind rhs) {
+  return !operator==(lhs, rhs);
+}
 
 // `ValueKind` is a subset of `Kind`, representing all valid `Kind` for `Value`.
 // All `ValueKind` are valid `Kind`, but it is not guaranteed that all `Kind`
@@ -155,41 +163,44 @@ enum class ValueKind : std::underlying_type_t<Kind> {
       static_cast<int>(Kind::kNotForUseWithExhaustiveSwitchStatements),
 };
 
-inline Kind ValueKindToKind(ValueKind kind) {
-  return absl::bit_cast<Kind>(kind);
+constexpr Kind ValueKindToKind(ValueKind kind) {
+  return static_cast<Kind>(
+      static_cast<std::underlying_type_t<ValueKind>>(kind));
 }
 
-ABSL_ATTRIBUTE_PURE_FUNCTION bool KindIsValueKind(Kind kind);
+constexpr bool KindIsValueKind(Kind kind) {
+  return kind != Kind::kWrapper && kind != Kind::kDyn && kind != Kind::kAny;
+}
 
-inline bool operator==(Kind lhs, ValueKind rhs) {
+constexpr bool operator==(Kind lhs, ValueKind rhs) {
   return lhs == ValueKindToKind(rhs);
 }
 
-inline bool operator==(ValueKind lhs, Kind rhs) {
+constexpr bool operator==(ValueKind lhs, Kind rhs) {
   return ValueKindToKind(lhs) == rhs;
 }
 
-inline bool operator==(TypeKind lhs, ValueKind rhs) {
+constexpr bool operator==(TypeKind lhs, ValueKind rhs) {
   return TypeKindToKind(lhs) == ValueKindToKind(rhs);
 }
 
-inline bool operator==(ValueKind lhs, TypeKind rhs) {
+constexpr bool operator==(ValueKind lhs, TypeKind rhs) {
   return ValueKindToKind(lhs) == TypeKindToKind(rhs);
 }
 
-inline bool operator!=(Kind lhs, ValueKind rhs) {
+constexpr bool operator!=(Kind lhs, ValueKind rhs) {
   return !operator==(lhs, rhs);
 }
 
-inline bool operator!=(ValueKind lhs, Kind rhs) {
+constexpr bool operator!=(ValueKind lhs, Kind rhs) {
   return !operator==(lhs, rhs);
 }
 
-inline bool operator!=(TypeKind lhs, ValueKind rhs) {
+constexpr bool operator!=(TypeKind lhs, ValueKind rhs) {
   return !operator==(lhs, rhs);
 }
 
-inline bool operator!=(ValueKind lhs, TypeKind rhs) {
+constexpr bool operator!=(ValueKind lhs, TypeKind rhs) {
   return !operator==(lhs, rhs);
 }
 
@@ -203,14 +214,15 @@ inline absl::string_view ValueKindToString(ValueKind kind) {
   return KindToString(ValueKindToKind(kind));
 }
 
-inline TypeKind KindToTypeKind(Kind kind) {
-  ABSL_DCHECK(KindIsTypeKind(kind)) << KindToString(kind);
-  return absl::bit_cast<TypeKind>(kind);
+constexpr TypeKind KindToTypeKind(Kind kind) {
+  ABSL_ASSERT(KindIsTypeKind(kind));
+  return static_cast<TypeKind>(static_cast<std::underlying_type_t<Kind>>(kind));
 }
 
-inline ValueKind KindToValueKind(Kind kind) {
-  ABSL_DCHECK(KindIsValueKind(kind)) << KindToString(kind);
-  return absl::bit_cast<ValueKind>(kind);
+constexpr ValueKind KindToValueKind(Kind kind) {
+  ABSL_ASSERT(KindIsValueKind(kind));
+  return static_cast<ValueKind>(
+      static_cast<std::underlying_type_t<Kind>>(kind));
 }
 
 }  // namespace cel