GSB: Stop computing 'derived via concrete' sources

Author: slavapestov

include/swift/AST/GenericSignatureBuilder.h

@@ -1229,8 +1229,7 @@ class GenericSignatureBuilder::RequirementSource final
   /// requirement redundant, because without said original requirement, the
   /// derived requirement ceases to hold.
   bool isSelfDerivedSource(GenericSignatureBuilder &builder,
-                           Type type,
-                           bool &derivedViaConcrete) const;
+                           Type type) const;
 
   /// For a requirement source that describes the requirement \c type:proto,
   /// retrieve the minimal subpath of this requirement source that will
@@ -1242,8 +1241,7 @@ class GenericSignatureBuilder::RequirementSource final
   const RequirementSource *getMinimalConformanceSource(
                                             GenericSignatureBuilder &builder,
                                             Type type,
-                                            ProtocolDecl *proto,
-                                            bool &derivedViaConcrete) const;
+                                            ProtocolDecl *proto) const;
 
   /// Retrieve a source location that corresponds to the requirement.
   SourceLoc getLoc() const;

lib/AST/GenericSignatureBuilder.cpp

@@ -930,10 +930,8 @@ bool RequirementSource::shouldDiagnoseRedundancy(bool primary) const {
 }
 
 bool RequirementSource::isSelfDerivedSource(GenericSignatureBuilder &builder,
-                                            Type type,
-                                            bool &derivedViaConcrete) const {
-  return getMinimalConformanceSource(builder, type, /*proto=*/nullptr,
-                                     derivedViaConcrete)
+                                            Type type) const {
+  return getMinimalConformanceSource(builder, type, /*proto=*/nullptr)
     != this;
 }
 
@@ -983,10 +981,7 @@ static bool isSelfDerivedProtocolRequirementInProtocol(
 const RequirementSource *RequirementSource::getMinimalConformanceSource(
                                              GenericSignatureBuilder &builder,
                                              Type currentType,
-                                             ProtocolDecl *proto,
-                                             bool &derivedViaConcrete) const {
-  derivedViaConcrete = false;
-
+                                             ProtocolDecl *proto) const {
   // If it's not a derived requirement, it's not self-derived.
   if (!isDerivedRequirement()) return this;
 
@@ -1053,15 +1048,6 @@ const RequirementSource *RequirementSource::getMinimalConformanceSource(
                                           ArchetypeResolutionKind::WellFormed);
       assert(parentEquivClass && "Not a well-formed type?");
 
-      if (requirementSignatureSelfProto) {
-        if (parentEquivClass->concreteType)
-          derivedViaConcrete = true;
-        else if (parentEquivClass->superclass &&
-                 builder.lookupConformance(parentEquivClass->superclass,
-                                           source->getProtocolDecl()))
-          derivedViaConcrete = true;
-      }
-
       // The parent potential archetype must conform to the protocol in which
       // this requirement resides. Add this constraint.
       if (auto startOfPath =
@@ -1130,7 +1116,7 @@ const RequirementSource *RequirementSource::getMinimalConformanceSource(
                               redundantSubpath->first,
                               redundantSubpath->second);
     return shorterSource
-      ->getMinimalConformanceSource(builder, currentType, proto, derivedViaConcrete);
+      ->getMinimalConformanceSource(builder, currentType, proto);
   }
 
   // It's self-derived but we don't have a redundant subpath to eliminate.
@@ -2824,13 +2810,10 @@ static void concretizeNestedTypeFromConcreteParent(
   const RequirementSource *parentConcreteSource = nullptr;
 
   for (const auto &constraint : parentEquiv->conformsTo.find(proto)->second) {
-    bool derivedViaConcrete = false;
-
     auto *minimal = constraint.source->getMinimalConformanceSource(
-        builder, constraint.getSubjectDependentType({ }), proto,
-        derivedViaConcrete);
+        builder, constraint.getSubjectDependentType({ }), proto);
 
-    if (minimal == nullptr || derivedViaConcrete)
+    if (minimal == nullptr)
       continue;
 
     if (!isSuperclassConstrained) {
@@ -5679,13 +5662,10 @@ static void expandSameTypeConstraints(GenericSignatureBuilder &builder,
       bool alreadyFound = false;
       const RequirementSource *conformsSource = nullptr;
       for (const auto &constraint : conforms.second) {
-        bool derivedViaConcrete = false;
-
         auto *minimal = constraint.source->getMinimalConformanceSource(
-            builder, constraint.getSubjectDependentType({ }), proto,
-            derivedViaConcrete);
+            builder, constraint.getSubjectDependentType({ }), proto);
 
-        if (minimal == nullptr || derivedViaConcrete)
+        if (minimal == nullptr)
           continue;
 
         if (minimal->getAffectedType()->isEqual(dependentType)) {
@@ -5910,18 +5890,14 @@ void GenericSignatureBuilder::computeRedundantRequirements(
           requirementSignatureSelfProto,
           [&](const Constraint<ProtocolDecl *> &constraint) {
             // FIXME: Remove this.
-            bool derivedViaConcrete;
             auto minimalSource =
               constraint.source->getMinimalConformanceSource(
                   *this,
                   constraint.getSubjectDependentType({ }),
-                  proto, derivedViaConcrete);
+                  proto);
             if (minimalSource != constraint.source)
               return true;
 
-            if (derivedViaConcrete)
-              return true;
-
             return false;
           });
 
@@ -6495,27 +6471,21 @@ void GenericSignatureBuilder::processDelayedRequirements() {
 
 namespace {
   /// Remove self-derived sources from the given vector of constraints.
-  ///
-  /// \returns true if any derived-via-concrete constraints were found.
   template<typename T>
-  bool removeSelfDerived(GenericSignatureBuilder &builder,
+  void removeSelfDerived(GenericSignatureBuilder &builder,
                          std::vector<Constraint<T>> &constraints,
                          ProtocolDecl *proto,
-                         bool dropDerivedViaConcrete = true,
                          bool allCanBeSelfDerived = false) {
     auto genericParams = builder.getGenericParams();
-    bool anyDerivedViaConcrete = false;
-    Optional<Constraint<T>> remainingConcrete;
     SmallVector<Constraint<T>, 4> minimalSources;
     constraints.erase(
       std::remove_if(constraints.begin(), constraints.end(),
         [&](const Constraint<T> &constraint) {
-          bool derivedViaConcrete;
           auto minimalSource =
             constraint.source->getMinimalConformanceSource(
                          builder,
                          constraint.getSubjectDependentType(genericParams),
-                         proto, derivedViaConcrete);
+                         proto);
           if (minimalSource != constraint.source) {
             // The minimal source is smaller than the original source, so the
             // original source is self-derived.
@@ -6532,21 +6502,8 @@ namespace {
             return true;
           }
 
-           if (!derivedViaConcrete)
-             return false;
-
-           anyDerivedViaConcrete = true;
-
-           if (!dropDerivedViaConcrete)
-             return false;
-
-           // Drop derived-via-concrete requirements.
-           if (!remainingConcrete)
-             remainingConcrete = constraint;
-
-           ++NumSelfDerived;
-           return true;
-         }),
+          return false;
+        }),
       constraints.end());
 
     // If we found any minimal sources, add them now, avoiding introducing any
@@ -6566,13 +6523,8 @@ namespace {
       }
     }
 
-    // If we only had concrete conformances, put one back.
-    if (constraints.empty() && remainingConcrete)
-      constraints.push_back(*remainingConcrete);
-
     assert((!constraints.empty() || allCanBeSelfDerived) &&
            "All constraints were self-derived!");
-    return anyDerivedViaConcrete;
   }
 } // end anonymous namespace
 
@@ -7135,9 +7087,7 @@ static void computeDerivedSameTypeComponents(
     // construction of self-derived sources really don't work, because we
     // discover more information later, so we need a more on-line or
     // iterative approach.
-    bool derivedViaConcrete;
-    if (concrete.source->isSelfDerivedSource(builder, subjectType,
-                                             derivedViaConcrete))
+    if (concrete.source->isSelfDerivedSource(builder, subjectType))
       continue;
 
     // If it has a better source than we'd seen before for this component,
@@ -7471,13 +7421,10 @@ void GenericSignatureBuilder::checkSameTypeConstraints(
   if (!equivClass->derivedSameTypeComponents.empty())
     return;
 
-  bool anyDerivedViaConcrete = false;
   // Remove self-derived constraints.
-  if (removeSelfDerived(*this, equivClass->sameTypeConstraints,
-                        /*proto=*/nullptr,
-                        /*dropDerivedViaConcrete=*/false,
-                        /*allCanBeSelfDerived=*/true))
-    anyDerivedViaConcrete = true;
+  removeSelfDerived(*this, equivClass->sameTypeConstraints,
+                    /*proto=*/nullptr,
+                    /*allCanBeSelfDerived=*/true);
 
   // Sort the constraints, so we get a deterministic ordering of diagnostics.
   llvm::array_pod_sort(equivClass->sameTypeConstraints.begin(),
@@ -7555,16 +7502,6 @@ void GenericSignatureBuilder::checkSameTypeConstraints(
       IntercomponentEdge(firstComponentIdx, secondComponentIdx, constraint));
   }
 
-  // If there were any derived-via-concrete constraints, drop them now before
-  // we emit other diagnostics.
-  if (anyDerivedViaConcrete) {
-    // Remove derived-via-concrete constraints.
-    (void)removeSelfDerived(*this, equivClass->sameTypeConstraints,
-                            /*proto=*/nullptr,
-                            /*dropDerivedViaConcrete=*/true,
-                            /*allCanBeSelfDerived=*/true);
-  }
-
   // Walk through each of the components, checking the intracomponent edges.
   // This will diagnose any explicitly-specified requirements within a
   // component, all of which are redundant.
@@ -7762,7 +7699,6 @@ void GenericSignatureBuilder::checkConcreteTypeConstraints(
 
   removeSelfDerived(*this, equivClass->concreteTypeConstraints,
                     /*proto=*/nullptr,
-                    /*dropDerivedViaConcrete=*/true,
                     /*allCanBeSelfDerived=*/true);
 
   // This can occur if the combination of a superclass requirement and

test/Generics/requirement_inference.swift

@@ -328,7 +328,9 @@ struct X24<T: P20> : P24 {
 // CHECK-NEXT: Canonical requirement signature: <τ_0_0 where τ_0_0.A == X24<τ_0_0.B>, τ_0_0.B : P20>
 protocol P25a {
   associatedtype A: P24 // expected-warning{{redundant conformance constraint 'Self.A' : 'P24'}}
+  // expected-note@-1 {{conformance constraint 'Self.B' : 'P20' implied here}}
   associatedtype B: P20 where A == X24<B> // expected-note{{conformance constraint 'Self.A' : 'P24' implied here}}
+  // expected-warning@-1 {{redundant conformance constraint 'Self.B' : 'P20'}}
 }
 
 // CHECK-LABEL: .P25b@