[GSB] Drop derived-from-concrete superclass/layout/etc. constraints.

Apply the same logic used for self-derived conformance constraints,
where we drop constraints derived from concrete conformances, to the
remaining kinds of constraints covered by isSelfDerivedSource().

Author: DougGregor

include/swift/AST/GenericSignatureBuilder.h

@@ -1002,7 +1002,8 @@ class GenericSignatureBuilder::RequirementSource final
   /// requirement. Such "self-derived" requirements do not make the original
   /// requirement redundant, because without said original requirement, the
   /// derived requirement ceases to hold.
-  bool isSelfDerivedSource(PotentialArchetype *pa) const;
+  bool isSelfDerivedSource(PotentialArchetype *pa,
+                           bool &derivedViaConcrete) const;
 
   /// Determine whether a requirement \c pa: proto, when formed from this
   /// requirement source, is dependent on itself.

lib/AST/GenericSignatureBuilder.cpp

@@ -253,7 +253,10 @@ bool RequirementSource::isDerivedViaConcreteConformance() const {
   return false;
 }
 
-bool RequirementSource::isSelfDerivedSource(PotentialArchetype *pa) const {
+bool RequirementSource::isSelfDerivedSource(PotentialArchetype *pa,
+                                            bool &derivedViaConcrete) const {
+  derivedViaConcrete = false;
+
   // If it's not a derived requirement, it's not self-derived.
   if (!isDerivedRequirement()) return false;
 
@@ -274,10 +277,15 @@ bool RequirementSource::isSelfDerivedSource(PotentialArchetype *pa) const {
     case RequirementSource::Parent:
       return currentPA->isInSameEquivalenceClassAs(pa);
 
-    case RequirementSource::NestedTypeNameMatch:
-    case RequirementSource::Concrete:
     case RequirementSource::ProtocolRequirement:
     case RequirementSource::InferredProtocolRequirement:
+      // Note whether we saw derivation through a concrete type.
+      if (currentPA->isConcreteType())
+        derivedViaConcrete = true;
+      return false;
+
+    case RequirementSource::NestedTypeNameMatch:
+    case RequirementSource::Concrete:
     case RequirementSource::Superclass:
       return false;
     }
@@ -3768,6 +3776,38 @@ Constraint<T> GenericSignatureBuilder::checkConstraintList(
                                    /*removeSelfDerived=*/true);
 }
 
+namespace {
+  /// Remove self-derived sources from the given vector of constraints.
+  template<typename T>
+  void removeSelfDerived(std::vector<Constraint<T>> &constraints) {
+    // Remove self-derived constraints.
+    Optional<Constraint<T>> remainingConcrete;
+    constraints.erase(
+      std::remove_if(constraints.begin(), constraints.end(),
+                     [&](const Constraint<T> &constraint) {
+                       bool derivedViaConcrete;
+                       if (constraint.source->isSelfDerivedSource(
+                                constraint.archetype, derivedViaConcrete))
+                         return true;
+
+                       if (!derivedViaConcrete)
+                         return false;
+
+                       // Drop derived-via-concrete requirements.
+                       if (!remainingConcrete)
+                         remainingConcrete = constraint;
+
+                       return true;
+                     }),
+      constraints.end());
+
+    if (constraints.empty() && remainingConcrete)
+      constraints.push_back(*remainingConcrete);
+
+    assert(!constraints.empty() && "All constraints were self-derived!");
+  }
+}
+
 template<typename T, typename DiagT>
 Constraint<T> GenericSignatureBuilder::checkConstraintList(
                            ArrayRef<GenericTypeParamType *> genericParams,
@@ -3784,15 +3824,7 @@ Constraint<T> GenericSignatureBuilder::checkConstraintList(
                            bool removeSelfDerived) {
   assert(!constraints.empty() && "No constraints?");
   if (removeSelfDerived) {
-    // Remove self-derived constraints.
-    constraints.erase(
-      std::remove_if(constraints.begin(), constraints.end(),
-                     [&](const Constraint<T> &constraint) {
-                       return constraint.source->isSelfDerivedSource(
-                                constraint.archetype);
-                     }),
-      constraints.end());
-    assert(!constraints.empty() && "All constraints were self-derived!");
+    ::removeSelfDerived(constraints);
   }
 
   // Sort the constraints, so we get a deterministic ordering of diagnostics.
@@ -4132,15 +4164,7 @@ void GenericSignatureBuilder::checkSameTypeConstraints(
     auto &constraints = entry.second;
 
     // Remove self-derived constraints.
-    assert(!constraints.empty() && "No constraints?");
-    constraints.erase(
-      std::remove_if(constraints.begin(), constraints.end(),
-                     [&](const Constraint<PotentialArchetype *> &constraint) {
-                       return constraint.source->isSelfDerivedSource(
-                                constraint.archetype);
-                     }),
-      constraints.end());
-    assert(!constraints.empty() && "All constraints were self-derived!");
+    removeSelfDerived(constraints);
 
     // Sort the constraints, so we get a deterministic ordering of diagnostics.
     llvm::array_pod_sort(constraints.begin(), constraints.end());

test/Generics/requirement_inference.swift

@@ -363,4 +363,29 @@ protocol P25b {
 protocol P25c {
   associatedtype A: P24
   associatedtype B where A == X<B> // expected-error{{use of undeclared type 'X'}}
-}
+}
+
+// Similar to the above, but with superclass constraints.
+protocol P26 {
+  associatedtype C: X3
+}
+
+struct X26<T: X3> : P26 {
+  typealias C = T
+}
+
+// CHECK-LABEL: .P27a@
+// CHECK-NEXT: Requirement signature: <Self where Self.B : X3, Self.A == X26<Self.B>>
+// CHECK-NEXT: Canonical requirement signature: <τ_0_0 where τ_0_0.B : X3, τ_0_0.A == X26<τ_0_0.B>>
+protocol P27a {
+  associatedtype A: P26 // expected-warning{{redundant conformance constraint 'Self.A': 'P26'}}
+  associatedtype B where A == X26<B> // expected-note{{conformance constraint 'Self.A': 'P26' implied here}}
+}
+
+// CHECK-LABEL: .P27b@
+// CHECK-NEXT: Requirement signature: <Self where Self.B : X3, Self.A == X26<Self.B>>
+// CHECK-NEXT: Canonical requirement signature: <τ_0_0 where τ_0_0.B : X3, τ_0_0.A == X26<τ_0_0.B>>
+protocol P27b {
+  associatedtype A
+  associatedtype B where A == X26<B>
+}