Metadata and runtime support for suppressible protocol requirements

Introduce metadata and runtime support for describing conformances to
"suppressible" protocols such as `Copyable`. The metadata changes occur
in several different places:

* Context descriptors gain a flag bit to indicate when the type itself has
  suppressed one or more suppressible protocols (e.g., it is `~Copyable`).
  When the bit is set, the context will have a trailing
  `SuppressibleProtocolSet`, a 16-bit bitfield that records one bit for
  each suppressed protocol. Types with no suppressed conformances will
  leave the bit unset (so the metadata is unchanged), and older runtimes
  don't look at the bit, so they will ignore the extra data.
* Generic context descriptors gain a flag bit to indicate when the type
  has conditional conformances to suppressible protocols. When set,
  there will be trailing metadata containing another
  `SuppressibleProtocolSet` (a subset of the one in the main context
  descriptor) indicating which suppressible protocols have conditional
  conformances, followed by the actual lists of generic requirements
  for each of the conditional conformances. Again, if there are no
  conditional conformances to suppressible protocols, the bit won't be
  set. Old runtimes ignore the bit and any trailing metadata.
* Generic requirements get a new "kind", which provides an ignored
  protocol set (another `SuppressibleProtocolSet`) stating which
  suppressible protocols should *not* be checked for the subject type
  of the generic requirement. For example, this encodes a requirement
  like `T: ~Copyable`. These generic requirements can occur anywhere
  that there is a generic requirement list, e.g., conditional
  conformances and extended existentials. Older runtimes handle unknown
  generic requirement kinds by stating that the requirement isn't
  satisfied.

Extend the runtime to perform checking of the suppressible
conformances on generic arguments as part of checking generic
requirements. This checking follows the defaults of the language, which
is that every generic argument must conform to each of the suppressible
protocols unless there is an explicit generic requirement that states
which suppressible protocols to ignore. Thus, a generic parameter list
`<T, Y where T: ~Escapable>` will check that `T` is `Copyable` but
not that it is `Escapable`, and check that `U` is both `Copyable` and
`Escapable`. To implement this, we collect the ignored protocol sets
from these suppressed requirements while processing the generic
requirements, then check all of the generic arguments against any
conformances not suppressed.

Answering the actual question "does `X` conform to `Copyable`?" (for
any suppressible protocol) looks at the context descriptor metadata to
answer the question, e.g.,

1. If there is no "suppressed protocol set", then the type conforms.
This covers types that haven't suppressed any conformances, including
all types that predate noncopyable generics.
2. If the suppressed protocol set doesn't contain `Copyable`, then the
type conforms.
3. If the type is generic and has a conditional conformance to
`Copyable`, evaluate the generic requirements for that conditional
conformance to answer whether it conforms.

The procedure above handles the bits of a `SuppressibleProtocolSet`
opaquely, with no mapping down to specific protocols. Therefore, the
same implementation will work even with future suppressible protocols,
including back deployment.

The end result of this is that we can dynamically evaluate conditional
conformances to protocols that depend on conformances to suppressible
protocols.

Implements rdar://123466649.

Author: DougGregor

include/swift/ABI/GenericContext.h

@@ -21,6 +21,7 @@
 #include "swift/ABI/TargetLayout.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/ABI/MetadataRef.h"
+#include "swift/ABI/SuppressibleProtocols.h"
 #include "swift/ABI/TrailingObjects.h"
 #include "swift/Demangling/Demangle.h"
 
@@ -103,6 +104,10 @@ struct TargetGenericContextDescriptorHeader {
   bool hasArguments() const {
     return getNumArguments() > 0;
   }
+
+  bool hasConditionalSuppressedProtocols() const {
+    return Flags.hasConditionalSuppressedProtocols();
+  }
 };
 using GenericContextDescriptorHeader =
   TargetGenericContextDescriptorHeader<InProcess>;
@@ -137,6 +142,20 @@ class TargetGenericRequirementDescriptor {
     ///
     /// Only valid if the requirement has Layout kind.
     GenericRequirementLayoutKind Layout;
+
+    /// The set of suppressible protocols whose check is suppressed, along
+    /// with the index of the generic parameter being suppressed.
+    ///
+    /// The index is technically redundant with the subject type, but its
+    /// storage is effectively free because this union is 32 bits anyway. The
+    /// index 0xFFFF is reserved for "not a generic parameter", in case we
+    /// need to use that in the future.
+    ///
+    /// Only valid if the requirement has SuppressedProtocols kind.
+    struct {
+      uint16_t GenericParamIndex;
+      SuppressibleProtocolSet Protocols;
+    } SuppressedProtocols;
   };
 
   constexpr GenericRequirementFlags getFlags() const {
@@ -204,6 +223,18 @@ class TargetGenericRequirementDescriptor {
     return Layout;
   }
 
+  /// Retrieve the set of suppressed protocols.
+  SuppressibleProtocolSet getSuppressedProtocols() const {
+    assert(getKind() == GenericRequirementKind::SuppressedProtocols);
+    return SuppressedProtocols.Protocols;
+  }
+
+  /// Retrieve the suppressible protocol kind.
+  uint16_t getSuppressedProtocolsGenericParamIndex() const {
+    assert(getKind() == GenericRequirementKind::SuppressedProtocols);
+    return SuppressedProtocols.GenericParamIndex;
+  }
+
   /// Determine whether this generic requirement has a known kind.
   ///
   /// \returns \c false for any future generic requirement kinds.
@@ -215,6 +246,7 @@ class TargetGenericRequirementDescriptor {
     case GenericRequirementKind::SameConformance:
     case GenericRequirementKind::SameType:
     case GenericRequirementKind::SameShape:
+    case GenericRequirementKind::SuppressedProtocols:
       return true;
     }
 
@@ -266,6 +298,20 @@ struct GenericPackShapeDescriptor {
   uint16_t Unused;
 };
 
+/// A count for the number of requirements for the number of requirements
+/// for a given conditional conformance to a suppressible protocols.
+struct ConditionalSuppressibleProtocolsRequirementCount {
+  uint16_t count;
+};
+
+/// A generic requirement for describing a conditional conformance to a
+/// suppressible protocol.
+///
+/// This type is equivalent to a `TargetGenericRequirementDescriptor`, and
+/// differs only because it needs to occur alongside
+template<typename Runtime>
+struct TargetConditionalSuppressibleProtocolRequirement: TargetGenericRequirementDescriptor<Runtime> { };
+
 /// An array of generic parameter descriptors, all
 /// GenericParamDescriptor::implicit(), which is by far
 /// the most common case.  Some generic context storage can
@@ -306,7 +352,8 @@ class RuntimeGenericSignature {
 
 public:
   RuntimeGenericSignature()
-    : Header{0, 0, 0, 0}, Params(nullptr), Requirements(nullptr),
+    : Header{0, 0, 0, GenericContextDescriptorFlags(false, false)},
+      Params(nullptr), Requirements(nullptr),
       PackShapeHeader{0, 0}, PackShapeDescriptors(nullptr) {}
 
   RuntimeGenericSignature(const TargetGenericContextDescriptorHeader<Runtime> &header,
@@ -425,20 +472,27 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
       TargetGenericRequirementDescriptor<Runtime>,
       GenericPackShapeHeader,
       GenericPackShapeDescriptor,
+      SuppressibleProtocolSet,
+      ConditionalSuppressibleProtocolsRequirementCount,
+      TargetConditionalSuppressibleProtocolRequirement<Runtime>,
       FollowingTrailingObjects...>
 {
 protected:
   using Self = TargetSelf<Runtime>;
   using GenericContextHeaderType = TargetGenericContextHeaderType<Runtime>;
   using GenericRequirementDescriptor =
     TargetGenericRequirementDescriptor<Runtime>;
-
+  using GenericConditionalSuppressibleProtocolRequirement =
+    TargetConditionalSuppressibleProtocolRequirement<Runtime>;
   using TrailingObjects = swift::ABI::TrailingObjects<Self,
     GenericContextHeaderType,
     GenericParamDescriptor,
     GenericRequirementDescriptor,
     GenericPackShapeHeader,
     GenericPackShapeDescriptor,
+    SuppressibleProtocolSet,
+    ConditionalSuppressibleProtocolsRequirementCount,
+    GenericConditionalSuppressibleProtocolRequirement,
     FollowingTrailingObjects...>;
   friend TrailingObjects;
 
@@ -467,7 +521,83 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
     /// HeaderType ought to be convertible to GenericContextDescriptorHeader.
     return getFullGenericContextHeader();
   }
-  
+
+  bool hasConditionalSuppressedProtocols() const {
+    if (!asSelf()->isGeneric())
+      return false;
+
+    return getGenericContextHeader().hasConditionalSuppressedProtocols();
+  }
+
+  const SuppressibleProtocolSet &
+  getConditionalSuppressedProtocols() const {
+    assert(hasConditionalSuppressedProtocols());
+    return *this->template getTrailingObjects<SuppressibleProtocolSet>();
+  }
+
+  /// Retrieve the counts for # of conditional suppressible protocols for each
+  /// conditional conformance to a suppressible protocol.
+  ///
+  /// The counts are cumulative, so the first entry in the array is the
+  /// number of requirements for the first conditional conformance. The
+  /// second entry in the array is the number of requirements in the first
+  /// and second conditional conformances. The last entry is, therefore, the
+  /// total count of requirements in the structure.
+  llvm::ArrayRef<ConditionalSuppressibleProtocolsRequirementCount>
+  getConditionalSuppressibleProtocolRequirementCounts() const {
+    if (!asSelf()->hasConditionalSuppressedProtocols())
+      return {};
+
+    return {
+      this->template
+        getTrailingObjects<ConditionalSuppressibleProtocolsRequirementCount>(),
+      getNumConditionalSuppressibleProtocolsRequirementCounts()
+    };
+  }
+
+  /// Retrieve the array of requirements for conditional conformances to
+  /// the ith conditional conformance to a suppressible protocol.
+  llvm::ArrayRef<GenericConditionalSuppressibleProtocolRequirement>
+  getConditionalSuppressibleProtocolRequirementsAt(unsigned i) const {
+    auto counts = getConditionalSuppressibleProtocolRequirementCounts();
+    assert(i < counts.size());
+
+    unsigned startIndex = (i == 0) ? 0 : counts[i-1].count;
+    unsigned endIndex = counts[i].count;
+
+    auto basePtr =
+      this->template
+        getTrailingObjects<GenericConditionalSuppressibleProtocolRequirement>();
+    return { basePtr + startIndex, basePtr + endIndex };
+  }
+
+  /// Retrieve the array of requirements for conditional conformances to
+  /// the ith conditional conformance to a suppressible protocol.
+  llvm::ArrayRef<GenericConditionalSuppressibleProtocolRequirement>
+  getConditionalSuppressibleProtocolRequirementsFor(
+      SuppressibleProtocolKind kind
+  ) const {
+    if (!asSelf()->hasConditionalSuppressedProtocols())
+      return { };
+
+    auto conditionallySuppressed = getConditionalSuppressedProtocols();
+    if (!conditionallySuppressed.contains(kind))
+      return { };
+
+    // Count the number of "set" bits up to (but not including) the
+    // bit we're looking at.
+    unsigned targetBit = static_cast<uint8_t>(kind);
+    auto suppressedBits = conditionallySuppressed.rawBits();
+    unsigned priorBits = 0;
+    for (unsigned i = 0; i != targetBit; ++i) {
+      if (suppressedBits & 0x01)
+        ++priorBits;
+      suppressedBits = suppressedBits >> 1;
+    }
+
+    return getConditionalSuppressibleProtocolRequirementsAt(priorBits);
+  }
+
   const TargetGenericContext<Runtime> *getGenericContext() const {
     if (!asSelf()->isGeneric())
       return nullptr;
@@ -549,6 +679,30 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
     return getGenericPackShapeHeader().NumPacks;
   }
 
+  size_t numTrailingObjects(OverloadToken<SuppressibleProtocolSet>) const {
+    return asSelf()->hasConditionalSuppressedProtocols() ? 1 : 0;
+  }
+
+  unsigned getNumConditionalSuppressibleProtocolsRequirementCounts() const {
+    if (!asSelf()->hasConditionalSuppressedProtocols())
+      return 0;
+
+    return countBitsUsed(getConditionalSuppressedProtocols().rawBits());
+  }
+
+  size_t numTrailingObjects(
+      OverloadToken<ConditionalSuppressibleProtocolsRequirementCount>
+  ) const {
+    return getNumConditionalSuppressibleProtocolsRequirementCounts();
+  }
+
+  size_t numTrailingObjects(
+      OverloadToken<GenericConditionalSuppressibleProtocolRequirement>
+  ) const {
+    auto counts = getConditionalSuppressibleProtocolRequirementCounts();
+    return counts.empty() ? 0 : counts.back().count;
+  }
+
 #if defined(_MSC_VER) && _MSC_VER < 1920
 #undef OverloadToken
 #endif