[NFC] AST: Define "repressible" known protocol.

This is the subset of suppressible protocols that are not invertible.
This commit doesn't add any such protocols.

Author: nate-chandler

include/swift/AST/KnownProtocols.def

@@ -49,6 +49,16 @@
     PROTOCOL_WITH_NAME(Id, Name)
 #endif
 
+/// \def REPRESSIBLE_PROTOCOL_WITH_NAME(id, name)
+/// \param id the internal "enum name" of this protocol
+/// \param name a string literal with the external name of this protocol
+#ifndef REPRESSIBLE_PROTOCOL_WITH_NAME
+#define REPRESSIBLE_PROTOCOL_WITH_NAME(Id, Name) \
+    PROTOCOL_WITH_NAME(Id, Name)
+#endif
+
+#define REPRESSIBLE_PROTOCOL(name) REPRESSIBLE_PROTOCOL_WITH_NAME(name, #name)
+#define REPRESSIBLE_PROTOCOL_(name) REPRESSIBLE_PROTOCOL_WITH_NAME(name, "_" #name)
 
 #define PROTOCOL(name) PROTOCOL_WITH_NAME(name, #name)
 #define PROTOCOL_(name) PROTOCOL_WITH_NAME(name, "_" #name)
@@ -169,6 +179,9 @@ BUILTIN_EXPRESSIBLE_BY_LITERAL_PROTOCOL_(ExpressibleByBuiltinUnicodeScalarLitera
 #undef EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME
 #undef BUILTIN_EXPRESSIBLE_BY_LITERAL_PROTOCOL_
 #undef BUILTIN_EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME
+#undef REPRESSIBLE_PROTOCOL_WITH_NAME
+#undef REPRESSIBLE_PROTOCOL
+#undef REPRESSIBLE_PROTOCOL_
 #undef INVERTIBLE_PROTOCOL_WITH_NAME
 #undef PROTOCOL
 #undef PROTOCOL_

include/swift/AST/KnownProtocols.h

@@ -28,6 +28,11 @@ enum class KnownProtocolKind : uint8_t {
 #include "swift/AST/KnownProtocols.def"
 };
 
+enum class RepressibleProtocolKind : uint8_t {
+#define REPRESSIBLE_PROTOCOL_WITH_NAME(Id, Name) Id,
+#include "swift/AST/KnownProtocols.def"
+};
+
 enum : uint8_t {
   // This uses a preprocessor trick to count all the protocols. The enum value
   // expression below expands to "+1+1+1...". (Note that the first plus
@@ -44,6 +49,14 @@ enum : unsigned { NumKnownProtocolKindBits =
 /// Retrieve the name of the given known protocol.
 llvm::StringRef getProtocolName(KnownProtocolKind kind);
 
+std::optional<RepressibleProtocolKind>
+getRepressibleProtocolKind(KnownProtocolKind kp);
+
+KnownProtocolKind getKnownProtocolKind(RepressibleProtocolKind ip);
+
+void simple_display(llvm::raw_ostream &out,
+                    const RepressibleProtocolKind &value);
+
 /// MARK: Invertible protocols
 ///
 /// The invertible protocols are a subset of the known protocols.
@@ -71,4 +84,27 @@ void simple_display(llvm::raw_ostream &out,
 
 } // end namespace swift
 
+namespace llvm {
+template <typename T, typename Enable>
+struct DenseMapInfo;
+template <>
+struct DenseMapInfo<swift::RepressibleProtocolKind> {
+  using RepressibleProtocolKind = swift::RepressibleProtocolKind;
+  using Impl = DenseMapInfo<uint8_t>;
+  static inline RepressibleProtocolKind getEmptyKey() {
+    return (RepressibleProtocolKind)Impl::getEmptyKey();
+  }
+  static inline RepressibleProtocolKind getTombstoneKey() {
+    return (RepressibleProtocolKind)Impl::getTombstoneKey();
+  }
+  static unsigned getHashValue(const RepressibleProtocolKind &Val) {
+    return Impl::getHashValue((uint8_t)Val);
+  }
+  static bool isEqual(const RepressibleProtocolKind &LHS,
+                      const RepressibleProtocolKind &RHS) {
+    return LHS == RHS;
+  }
+};
+} // namespace llvm
+
 #endif

lib/AST/ASTContext.cpp

@@ -130,6 +130,33 @@ void swift::simple_display(llvm::raw_ostream &out,
   out << getProtocolName(getKnownProtocolKind(value));
 }
 
+std::optional<RepressibleProtocolKind>
+swift::getRepressibleProtocolKind(KnownProtocolKind kp) {
+  switch (kp) {
+#define REPRESSIBLE_PROTOCOL_WITH_NAME(Id, Name)                               \
+  case KnownProtocolKind::Id:                                                  \
+    return RepressibleProtocolKind::Id;
+#include "swift/AST/KnownProtocols.def"
+  default:
+    return std::nullopt;
+  }
+}
+
+/// Returns the KnownProtocolKind corresponding to an RepressibleProtocolKind.
+KnownProtocolKind swift::getKnownProtocolKind(RepressibleProtocolKind ip) {
+  switch (ip) {
+#define REPRESSIBLE_PROTOCOL_WITH_NAME(Id, Name)                               \
+  case RepressibleProtocolKind::Id:                                            \
+    return KnownProtocolKind::Id;
+#include "swift/AST/KnownProtocols.def"
+  }
+}
+
+void swift::simple_display(llvm::raw_ostream &out,
+                           const RepressibleProtocolKind &value) {
+  out << getProtocolName(getKnownProtocolKind(value));
+}
+
 // Metadata stores a 16-bit field for invertible protocols. Trigger a build
 // error when we assign the 15th bit so we can think about what to do.
 #define INVERTIBLE_PROTOCOL(Name, Bit) \