Merge pull request #40256 from slavapestov/fix-gsb-conditional-requirement-inference-again

GSB: Tweak condition under which we perform conditional requirement inference

Author: slavapestov

lib/AST/GenericSignatureBuilder.cpp

@@ -1916,10 +1916,12 @@ bool EquivalenceClass::recordConformanceConstraint(
 
     // If there is a concrete type that resolves this conformance requirement,
     // record the conformance.
-    if (!builder.resolveConcreteConformance(type, proto)) {
+    bool explicitConformance = !source->isDerivedRequirement();
+
+    if (!builder.resolveConcreteConformance(type, proto, explicitConformance)) {
       // Otherwise, determine whether there is a superclass constraint where the
       // superclass conforms to this protocol.
-      (void)builder.resolveSuperConformance(type, proto);
+      (void)builder.resolveSuperConformance(type, proto, explicitConformance);
     }
   }
 
@@ -2324,7 +2326,8 @@ void GenericSignatureBuilder::addConditionalRequirements(
 
 const RequirementSource *
 GenericSignatureBuilder::resolveConcreteConformance(ResolvedType type,
-                                                    ProtocolDecl *proto) {
+                                                    ProtocolDecl *proto,
+                                                    bool explicitConformance) {
   auto equivClass = type.getEquivalenceClass(*this);
   auto concrete = equivClass->concreteType;
   if (!concrete) return nullptr;
@@ -2378,21 +2381,22 @@ GenericSignatureBuilder::resolveConcreteConformance(ResolvedType type,
   equivClass->recordConformanceConstraint(*this, type, proto, concreteSource);
 
   // Only infer conditional requirements from explicit sources.
-  bool hasExplicitSource = llvm::any_of(
+  bool explicitConcreteType = llvm::any_of(
       equivClass->concreteTypeConstraints,
       [](const ConcreteConstraint &constraint) {
         return !constraint.source->isDerivedRequirement();
       });
 
-  if (hasExplicitSource) {
+  if (explicitConformance || explicitConcreteType) {
     addConditionalRequirements(conformance, /*inferForModule=*/nullptr);
   }
 
   return concreteSource;
 }
-const RequirementSource *GenericSignatureBuilder::resolveSuperConformance(
-                                                        ResolvedType type,
-                                                        ProtocolDecl *proto) {
+const RequirementSource *
+GenericSignatureBuilder::resolveSuperConformance(ResolvedType type,
+                                                 ProtocolDecl *proto,
+                                                 bool explicitConformance) {
   // Get the superclass constraint.
   auto equivClass = type.getEquivalenceClass(*this);
   Type superclass = equivClass->superclass;
@@ -2418,14 +2422,13 @@ const RequirementSource *GenericSignatureBuilder::resolveSuperConformance(
   equivClass->recordConformanceConstraint(*this, type, proto, superclassSource);
 
   // Only infer conditional requirements from explicit sources.
-  bool hasExplicitSource = llvm::any_of(
-    equivClass->superclassConstraints,
-    [](const ConcreteConstraint &constraint) {
-      return (!constraint.source->isDerivedRequirement() &&
-              constraint.source->getLoc().isValid());
-    });
+  bool explicitSuperclass = llvm::any_of(
+      equivClass->superclassConstraints,
+      [](const ConcreteConstraint &constraint) {
+        return !constraint.source->isDerivedRequirement();
+      });
 
-  if (hasExplicitSource) {
+  if (explicitConformance || explicitSuperclass) {
     addConditionalRequirements(conformance, /*inferForModule=*/nullptr);
   }
 
@@ -4410,7 +4413,13 @@ bool GenericSignatureBuilder::updateSuperclass(
   // when the superclass constraint changes.
   auto updateSuperclassConformances = [&] {
     for (const auto &conforms : equivClass->conformsTo) {
-      (void)resolveSuperConformance(type, conforms.first);
+      bool explicitConformance = std::find_if(
+          conforms.second.begin(),
+          conforms.second.end(),
+          [](const Constraint<ProtocolDecl *> &constraint) {
+            return !constraint.source->isDerivedRequirement();
+          }) != conforms.second.end();
+      (void)resolveSuperConformance(type, conforms.first, explicitConformance);
     }
 
     // Eagerly resolve any existing nested types to their concrete forms (others
@@ -4809,8 +4818,15 @@ GenericSignatureBuilder::addSameTypeRequirementBetweenTypeParameters(
                                  equivClass2->concreteTypeConstraints.begin(),
                                  equivClass2->concreteTypeConstraints.end());
 
-    for (const auto &conforms : equivClass->conformsTo)
-      (void)resolveConcreteConformance(T1, conforms.first);
+    for (const auto &conforms : equivClass->conformsTo) {
+      bool explicitConformance = std::find_if(
+          conforms.second.begin(),
+          conforms.second.end(),
+          [](const Constraint<ProtocolDecl *> &constraint) {
+            return !constraint.source->isDerivedRequirement();
+          }) != conforms.second.end();
+      (void)resolveConcreteConformance(T1, conforms.first, explicitConformance);
+    }
   }
 
   // Make T1 the representative of T2, merging the equivalence classes.
@@ -4946,7 +4962,13 @@ ConstraintResult GenericSignatureBuilder::addSameTypeRequirementToConcrete(
   // Make sure the concrete type fulfills the conformance requirements of
   // this equivalence class.
   for (const auto &conforms : equivClass->conformsTo) {
-    if (!resolveConcreteConformance(type, conforms.first))
+    bool explicitConformance = std::find_if(
+        conforms.second.begin(),
+        conforms.second.end(),
+        [](const Constraint<ProtocolDecl *> &constraint) {
+          return !constraint.source->isDerivedRequirement();
+        }) != conforms.second.end();
+    if (!resolveConcreteConformance(type, conforms.first, explicitConformance))
       return ConstraintResult::Conflicting;
   }
 

lib/AST/GenericSignatureBuilder.h

@@ -338,7 +338,8 @@ class GenericSignatureBuilder {
   /// \returns the requirement source for the resolved conformance, or nullptr
   /// if the conformance could not be resolved.
   const RequirementSource *resolveConcreteConformance(ResolvedType type,
-                                                      ProtocolDecl *proto);
+                                                      ProtocolDecl *proto,
+                                                      bool explicitConformance);
 
   /// Retrieve the constraint source conformance for the superclass constraint
   /// of the given potential archetype (if present) to the given protocol.
@@ -347,7 +348,8 @@ class GenericSignatureBuilder {
   ///
   /// \param proto The protocol to which we are establishing conformance.
   const RequirementSource *resolveSuperConformance(ResolvedType type,
-                                                   ProtocolDecl *proto);
+                                                   ProtocolDecl *proto,
+                                                   bool explicitConformance);
 
 public:
   /// Add a new conformance requirement specifying that the given

test/Generics/conditional_requirement_inference.swift

@@ -8,6 +8,11 @@ struct EquatableBox<T : Equatable> {
   func withArray<U>(_: U) where T == Array<U> {}
 }
 
+struct EquatableSequenceBox<T : Sequence> where T.Element : Equatable {
+  // CHECK: Generic signature: <T, U where T == Array<Array<U>>, U : Equatable>
+  func withArrayArray<U>(_: U) where T == Array<Array<U>> {}
+}
+
 
 // A very elaborate invalid example (see comment in mergeP1AndP2())
 struct G<T> {}

test/SILGen/type_lowering_subst_function_type_conditional_conformance.swift

@@ -67,3 +67,30 @@ struct S4<Base> where Base : P1, Base.Element: P1 {
     _ = index.map({ _ = $0 })
   }
 }
+
+struct T0<X> {}
+
+extension T0: P1 where X: P1 {
+  typealias Element = X.Element
+  typealias Index = T0<X.Index>
+}
+
+struct T1<X, Y>: P1 where X: P1 {
+  typealias Element = Y
+  typealias Index = X.Index
+}
+
+struct T2<X> where X: P1, X.Element: P1 {
+  let field: X.Element.Index
+}
+
+struct T3<X> where X: P1 {
+  func callee(_: T2<T1<X, T0<X>>>) {}
+
+  // CHECK-LABEL: {{^}}sil {{.*}}2T3{{.*}}6caller{{.*}}F :
+  // CHECK: @callee_guaranteed @substituted <τ_0_0, τ_0_1, τ_0_2, τ_0_3, τ_0_4, τ_0_5 where τ_0_0 == T1<τ_0_1, T0<τ_0_4>>, τ_0_1 : P1, τ_0_1 == τ_0_3, τ_0_2 == T0<τ_0_4>, τ_0_4 : P1, τ_0_4 == τ_0_5> (T2<T1<τ_0_1, T0<τ_0_4>>>) -> () for <T1<X, T0<X>>, X, T0<X>, X, X, X>
+  func caller() {
+    _ = { (x: T2<T1<X, T0<X>>>) in callee(x) }
+  }
+}
+