Allow missing Sendable conformances when type parametesr are made concrete

lib/AST/RequirementMachine/ConcreteContraction.cpp

@@ -223,7 +223,8 @@ Optional<Type> ConcreteContraction::substTypeParameter(
 
     auto conformance = ((*substBaseType)->isTypeParameter()
                         ? ProtocolConformanceRef(proto)
-                        : module->lookupConformance(*substBaseType, proto));
+                        : module->lookupConformance(*substBaseType, proto,
+                                                    /*allowMissing=*/true));
 
     // The base type doesn't conform, in which case the requirement remains
     // unsubstituted.
@@ -363,7 +364,8 @@ ConcreteContraction::substRequirement(const Requirement &req) const {
     auto *proto = req.getProtocolDecl();
     auto *module = proto->getParentModule();
     if (!substFirstType->isTypeParameter() &&
-        !module->lookupConformance(substFirstType, proto)) {
+        !module->lookupConformance(substFirstType, proto,
+                                   /*allowMissing=*/true)) {
       // Handle the case of <T where T : P, T : C> where C is a class and
       // C does not conform to P by leaving the conformance requirement
       // unsubstituted.
@@ -664,4 +666,4 @@ bool swift::rewriting::performConcreteContraction(
   ConcreteContraction concreteContraction(debug);
   return concreteContraction.performConcreteContraction(
       requirements, result, errors);
-}
+}

lib/AST/RequirementMachine/ConcreteTypeWitness.cpp

@@ -144,7 +144,8 @@ void PropertyMap::concretizeNestedTypesFromConcreteParent(
     auto *module = proto->getParentModule();
 
     auto conformance = module->lookupConformance(concreteType,
-                                                 const_cast<ProtocolDecl *>(proto));
+                                                 const_cast<ProtocolDecl *>(proto),
+                                                 /*allowMissing=*/true);
     if (conformance.isInvalid()) {
       // For superclass rules, it is totally fine to have a signature like:
       //

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -292,7 +292,8 @@ static void desugarConformanceRequirement(Type subjectType, Type constraintType,
       // Check if the subject type actually conforms.
       auto *protoDecl = constraintType->castTo<ProtocolType>()->getDecl();
       auto *module = protoDecl->getParentModule();
-      auto conformance = module->lookupConformance(subjectType, protoDecl);
+      auto conformance = module->lookupConformance(
+          subjectType, protoDecl, /*allowMissing=*/true);
       if (conformance.isInvalid()) {
         errors.push_back(RequirementError::forInvalidRequirementSubject(
             {RequirementKind::Conformance, subjectType, constraintType}, loc));

test/Concurrency/sendable_conformance_checking.swift

@@ -165,3 +165,29 @@ extension SendableExtSub: @unchecked Sendable {}
 // Still want to know about same-class redundancy
 class MultiConformance: @unchecked Sendable {} // expected-note {{'MultiConformance' declares conformance to protocol 'Sendable' here}}
 extension MultiConformance: @unchecked Sendable {} // expected-error {{redundant conformance of 'MultiConformance' to protocol 'Sendable'}}
+
+// rdar://91174106 - allow missing Sendable conformances when extending a
+// type generically.
+// FIXME: Should warn because of missing Sendable, but currently is silent
+// because we aren't checking conformance availability here yet.
+struct X<T: Sendable> { }
+enum Y {}
+extension X where T == Y {}
+
+protocol P2 {
+  associatedtype A: Sendable
+}
+
+enum Y2: P2, P3 {
+  typealias A = Y
+}
+
+struct X2<T: P2> { }
+extension X2 where T == Y2 { }
+
+protocol P3 {
+  associatedtype A
+}
+
+struct X3<T: P3> where T.A: Sendable { }
+extension X3 where T == Y2 { }