Merge pull request #42309 from slavapestov/rqm-sendable-conformance-5.7

RequirementMachine: Allow missing Sendable conformances [5.7]

Author: slavapestov

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.
@@ -362,8 +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)) {
+        !module->lookupConformance(substFirstType, proto,
+                                   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.
@@ -664,4 +682,4 @@ bool swift::rewriting::performConcreteContraction(
   ConcreteContraction concreteContraction(debug);
   return concreteContraction.performConcreteContraction(
       requirements, result, errors);
-}
+}

lib/AST/RequirementMachine/ConcreteTypeWitness.cpp

@@ -143,8 +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));
+                                                 const_cast<ProtocolDecl *>(proto),
+                                                 allowMissing);
     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/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 {}