IRGen: omit conditional reqs for invertible protos

Author: kavon

include/swift/AST/GenericSignature.h

@@ -213,6 +213,20 @@ class GenericSignature {
   SmallVector<Requirement, 4>
   requirementsNotSatisfiedBy(GenericSignature otherSig) const;
 
+  /// Return the requirements of this generic signature that are not also
+  /// satisfied by \c otherSig.
+  ///
+  /// Requirements for invertible protocols are omitted. Instead, their absence
+  /// in this generic signature is noted in the \c inverses output.
+  ///
+  /// \param otherSig Another generic signature whose generic parameters are
+  /// equivalent to or a subset of the generic parameters in this signature, and
+  /// whose inverses are a superset of the inverses in this generic signature.
+  void requirementsAndInversesWhenExtending(
+                            GenericSignature otherSig,
+                            SmallVector<Requirement, 2> &result,
+                            SmallVector<InverseRequirement, 2> &inverses) const;
+
   /// Return the reduced version of the given type under this generic
   /// signature.
   CanType getReducedType(Type type) const;
@@ -528,6 +542,20 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   SmallVector<Requirement, 4>
   requirementsNotSatisfiedBy(GenericSignature otherSig) const;
 
+  /// Return the requirements of this generic signature that are not also
+  /// satisfied by \c otherSig.
+  ///
+  /// Requirements for invertible protocols are omitted. Instead, their absence
+  /// in this generic signature is noted in the \c inverses output.
+  ///
+  /// \param otherSig Another generic signature whose generic parameters are
+  /// equivalent to or a subset of the generic parameters in this signature, and
+  /// whose inverses are a superset of the inverses in this generic signature.
+  void requirementsAndInversesWhenExtending(
+                            GenericSignature otherSig,
+                            SmallVector<Requirement, 2> &reqs,
+                            SmallVector<InverseRequirement, 2> &inverses) const;
+
   /// Return the reduced version of the given type under this generic
   /// signature.
   CanType getReducedType(Type type) const;

include/swift/AST/ProtocolConformance.h

@@ -595,6 +595,13 @@ class NormalProtocolConformance : public RootProtocolConformance,
   llvm::Optional<ArrayRef<Requirement>>
   getConditionalRequirementsIfAvailable() const;
 
+  /// Get any additional requirements that are required for this conformance to
+  /// be satisfied, and inverses, which indicate generic parameters that do
+  /// *not* require conformance to an invertible protocol.
+  void getConditionalRequirementsWithInverses(
+                            SmallVector<Requirement, 2> &requirements,
+                            SmallVector<InverseRequirement, 2> &inverses) const;
+
   /// Retrieve the state of this conformance.
   ProtocolConformanceState getState() const {
     return static_cast<ProtocolConformanceState>(

lib/AST/GenericSignature.cpp

@@ -479,6 +479,52 @@ SmallVector<Requirement, 4> GenericSignatureImpl::requirementsNotSatisfiedBy(
   return result;
 }
 
+void GenericSignature::requirementsAndInversesWhenExtending(
+                          GenericSignature otherSig,
+                          SmallVector<Requirement, 2> &result,
+                          SmallVector<InverseRequirement, 2> &inverses) const {
+  assert(!isNull()); // what to do about a null generic signature?
+  return getPointer()->requirementsAndInversesWhenExtending(otherSig,
+                                                            result,
+                                                            inverses);
+}
+
+
+void GenericSignatureImpl::requirementsAndInversesWhenExtending(
+                          GenericSignature otherSig,
+                          SmallVector<Requirement, 2> &result,
+                          SmallVector<InverseRequirement, 2> &inverses) const {
+  SmallVector<Requirement, 2> reqs;
+  getRequirementsWithInverses(reqs, inverses);
+
+  // If the signatures match by pointer, all requirements are satisfied.
+  if (otherSig.getPointer() == this) return;
+
+  // If there is no other signature, no requirements are satisfied.
+  if (!otherSig) {
+    result.append(reqs.begin(), reqs.end());
+    return;
+  }
+
+#ifndef NDEBUG
+  {
+    // Check that otherSig has the same or more inverses than this signature.
+    SmallVector<Requirement, 2> otherReqs;
+    SmallVector<InverseRequirement, 2> otherInverses;
+    otherSig->getRequirementsWithInverses(otherReqs, otherInverses);
+    assert(otherInverses.size() >= inverses.size()
+          && "otherSig's inverses are not a superset of this generic sig!");
+  };
+#endif
+
+  // Find the requirements that aren't satisfied.
+  for (const auto &req : reqs) {
+    if (!otherSig->isRequirementSatisfied(req))
+      reqs.push_back(req);
+  }
+
+}
+
 bool GenericSignatureImpl::isReducedType(Type type) const {
   // If the type isn't canonical, it's not reduced.
   if (!type->isCanonical())

lib/AST/ProtocolConformance.cpp

@@ -384,6 +384,43 @@ NormalProtocolConformance::getConditionalRequirements() const {
                            {});
 }
 
+void NormalProtocolConformance::getConditionalRequirementsWithInverses(
+                          SmallVector<Requirement, 2> &requirements,
+                          SmallVector<InverseRequirement, 2> &inverses) const {
+  // NOTE: This is mostly the same as `ConditionalRequirementsRequest::evaluate`
+  //       and we should consider combining the two.
+
+  // A non-extension conformance won't have conditional requirements.
+  const auto ext = dyn_cast<ExtensionDecl>(getDeclContext());
+  if (!ext) {
+    return;
+  }
+
+  // If the extension is invalid, it won't ever get a signature, so we
+  // "succeed" with an empty result instead.
+  if (ext->isInvalid()) {
+    return;
+  }
+
+  // A non-generic type won't have conditional requirements.
+  const auto typeSig = ext->getExtendedNominal()->getGenericSignature();
+  if (!typeSig) {
+    return;
+  }
+
+  const auto extensionSig = ext->getGenericSignature();
+
+  // The extension signature should be a superset of the type signature.
+  assert(typeSig.getCanonicalSignature().getGenericParams() ==
+      extensionSig.getCanonicalSignature().getGenericParams());
+
+  // Find the requirements in the extension that aren't proved by the original
+  // type, these are the ones that make the conformance conditional.
+  extensionSig.requirementsAndInversesWhenExtending(typeSig,
+                                                    requirements,
+                                                    inverses);
+}
+
 llvm::ArrayRef<Requirement>
 ConditionalRequirementsRequest::evaluate(Evaluator &evaluator,
                                          NormalProtocolConformance *NPC) const {

lib/IRGen/GenProto.cpp

@@ -2113,17 +2113,19 @@ namespace {
       if (!normal)
         return;
 
-      llvm::Optional<Requirement> scratchRequirement;
-      auto condReqs = normal->getConditionalRequirements();
+      // FIXME(kavon): probably need to emit the inverse requirements in the
+      //  metadata so the runtime knows not to check for Copyable?
+      SmallVector<Requirement, 2> condReqs;
+      SmallVector<InverseRequirement, 2> inverses;
+      normal->getConditionalRequirementsWithInverses(condReqs, inverses);
       if (condReqs.empty()) {
         // For a protocol P that conforms to another protocol, introduce a
         // conditional requirement for that P's Self: P. This aligns with
         // SILWitnessTable::enumerateWitnessTableConditionalConformances().
         if (auto selfProto = normal->getDeclContext()->getSelfProtocolDecl()) {
           auto selfType = selfProto->getSelfInterfaceType()->getCanonicalType();
-          scratchRequirement.emplace(RequirementKind::Conformance, selfType,
+          condReqs.emplace_back(RequirementKind::Conformance, selfType,
                                      selfProto->getDeclaredInterfaceType());
-          condReqs = *scratchRequirement;
         }
 
         if (condReqs.empty())