GSB: Tweak condition under which we perform conditional requirement inference

For SIL substituted generic signature construction to work, we must
perform this step if either the conformance requirement or the
concrete type requirement is explicit. Previously, we only did it
if the concrete type requirement was explicit.

This is still somewhat unprincipled and I need to think about it
some more before porting it over to the requirement machine.

Fixes https://bugs.swift.org/browse/SR-15254 / rdar://problem/84827656.

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) }
+  }
+}
+