RequirementMachine: Fix handling of Sendable conformances for superclass requirements

Don't set allowMissing to true when checking conformance of a superclass requirement
to a protocol, since this prevents us from being able to express something like
'T : C, T : Sendable' to mean 'T can be any subclass of C which is also Sendable'.

Fixes rdar://problem/91530343.

Author: slavapestov

lib/AST/RequirementMachine/ConcreteContraction.cpp

@@ -363,9 +363,25 @@ ConcreteContraction::substRequirement(const Requirement &req) const {
 
     auto *proto = req.getProtocolDecl();
     auto *module = proto->getParentModule();
+
+    // For conformance to 'Sendable', allow synthesis of a missing conformance
+    // if the generic parameter is concrete, that is, if we're looking at a
+    // signature of the form 'T == Foo, T : Sendable'.
+    //
+    // Otherwise, we have a superclass requirement, like 'T : C, T : Sendable';
+    // don't synthesize the conformance in this case since dropping
+    // 'T : Sendable' would be incorrect; we want to ensure that we only admit
+    // subclasses of 'C' which are 'Sendable'.
+    bool allowMissing = false;
+    if (auto *rootParam = firstType->getAs<GenericTypeParamType>()) {
+      auto key = GenericParamKey(rootParam);
+      if (ConcreteTypes.count(key) > 0)
+        allowMissing = true;
+    }
+
     if (!substFirstType->isTypeParameter() &&
         !module->lookupConformance(substFirstType, proto,
-                                   /*allowMissing=*/true)) {
+                                   allowMissing)) {
       // 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.

lib/AST/RequirementMachine/ConcreteTypeWitness.cpp

@@ -143,9 +143,19 @@ void PropertyMap::concretizeNestedTypesFromConcreteParent(
     // or pass the correct one down in here.
     auto *module = proto->getParentModule();
 
+    // For conformance to 'Sendable', allow synthesis of a missing conformance
+    // if the requirement is a concrete type requirement, that is, if we're
+    // looking at a signature of the form 'T == Foo, T : Sendable'.
+    //
+    // Otherwise, we have a superclass requirement, like 'T : C, T : Sendable'.
+    // Don't synthesize the conformance in this case since dropping
+    // 'T : Sendable' would be incorrect; we want to ensure that we only admit
+    // subclasses of 'C' which are 'Sendable'.
+    bool allowMissing = (requirementKind == RequirementKind::SameType);
+
     auto conformance = module->lookupConformance(concreteType,
                                                  const_cast<ProtocolDecl *>(proto),
-                                                 /*allowMissing=*/true);
+                                                 allowMissing);
     if (conformance.isInvalid()) {
       // For superclass rules, it is totally fine to have a signature like:
       //

test/Concurrency/sendable_conformance_checking.swift

@@ -165,29 +165,3 @@ 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 { }

test/Generics/missing_sendable_conformance.swift

@@ -0,0 +1,34 @@
+// RUN: %target-typecheck-verify-swift
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures 2>&1 | %FileCheck %s
+
+// REQUIRES: concurrency
+
+// 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.
+class C {}
+
+struct G1<T: Sendable> {}
+
+// CHECK-LABEL: ExtensionDecl line={{.*}} base=G1
+// CHECK-NEXT: Generic signature: <T where T == C>
+extension G1 where T == C {}
+
+// CHECK-LABEL: ExtensionDecl line={{.*}} base=G1
+// CHECK-NEXT: Generic signature: <T where T : C, T : Sendable>
+extension G1 where T : C {}
+
+protocol P {
+  associatedtype A
+}
+
+struct G2<T : P> where T.A : Sendable {}
+
+// CHECK-LABEL: ExtensionDecl line={{.*}} base=G2
+// CHECK-NEXT: Generic signature: <T where T : P, T.[P]A == C>
+extension G2 where T.A == C {}
+
+// CHECK-LABEL: ExtensionDecl line={{.*}} base=G2
+// CHECK-NEXT: Generic signature: <T where T : P, T.[P]A : C, T.[P]A : Sendable>
+extension G2 where T.A : C {}