[Concurrency] Downgrade Sendable requirement failures in existential

erasure expressions for arguments to `@preconcurrency` functions in Swift
6 mode.

(cherry picked from commit 806de5a)

Author: hborla

lib/Sema/TypeCheckAvailability.cpp

@@ -3442,6 +3442,7 @@ class ExprAvailabilityWalker : public ASTWalker {
   ASTContext &Context;
   MemberAccessContext AccessContext = MemberAccessContext::Default;
   SmallVector<const Expr *, 16> ExprStack;
+  SmallVector<bool, 4> PreconcurrencyCalleeStack;
   const ExportContext &Where;
 
 public:
@@ -3469,6 +3470,15 @@ class ExprAvailabilityWalker : public ASTWalker {
 
     ExprStack.push_back(E);
 
+    if (auto *apply = dyn_cast<ApplyExpr>(E)) {
+      bool preconcurrency = false;
+      auto declRef = apply->getFn()->getReferencedDecl();
+      if (auto *decl = declRef.getDecl()) {
+        preconcurrency = decl->preconcurrency();
+      }
+      PreconcurrencyCalleeStack.push_back(preconcurrency);
+    }
+
     if (auto DR = dyn_cast<DeclRefExpr>(E)) {
       diagnoseDeclRefAvailability(DR->getDeclRef(), DR->getSourceRange(),
                                   getEnclosingApplyExpr(), std::nullopt);
@@ -3573,9 +3583,15 @@ class ExprAvailabilityWalker : public ASTWalker {
                                               EE->getLoc(),
                                               Where.getDeclContext());
 
+      bool preconcurrency = false;
+      if (!PreconcurrencyCalleeStack.empty()) {
+        preconcurrency = PreconcurrencyCalleeStack.back();
+      }
+
       for (ProtocolConformanceRef C : EE->getConformances()) {
         diagnoseConformanceAvailability(E->getLoc(), C, Where, Type(), Type(),
-                                        /*useConformanceAvailabilityErrorsOpt=*/true);
+                                        /*useConformanceAvailabilityErrorsOpt=*/true,
+                                        /*preconcurrency=*/preconcurrency);
       }
     }
 
@@ -3601,6 +3617,10 @@ class ExprAvailabilityWalker : public ASTWalker {
     assert(ExprStack.back() == E);
     ExprStack.pop_back();
 
+    if (auto *apply = dyn_cast<ApplyExpr>(E)) {
+      PreconcurrencyCalleeStack.pop_back();
+    }
+
     return Action::Continue(E);
   }
 

test/Concurrency/predates_concurrency_swift6.swift

@@ -180,7 +180,7 @@ func requireSendable<T: Sendable>(_: T) {}
 @preconcurrency
 struct RequireSendable<T: Sendable> {}
 
-class NotSendable {} // expected-note 2 {{class 'NotSendable' does not conform to the 'Sendable' protocol}}
+class NotSendable {} // expected-note 4 {{class 'NotSendable' does not conform to the 'Sendable' protocol}}
 
 typealias T = RequireSendable<NotSendable>
 // expected-warning@-1 {{type 'NotSendable' does not conform to the 'Sendable' protocol}}
@@ -189,3 +189,24 @@ func testRequirementDowngrade(ns: NotSendable) {
   requireSendable(ns)
   // expected-warning@-1 {{type 'NotSendable' does not conform to the 'Sendable' protocol}}
 }
+
+
+protocol P2 {}
+
+extension NotSendable: P2 {}
+
+@preconcurrency
+func requireSendableExistential(_: any P2 & Sendable) {}
+
+func requireSendableExistentialAlways(_: any P2 & Sendable) {}
+
+func testErasureDowngrade(ns: NotSendable) {
+  requireSendableExistential(ns)
+  // expected-warning@-1 {{type 'NotSendable' does not conform to the 'Sendable' protocol}}
+
+  withSendableClosure {
+    let ns = NotSendable()
+    requireSendableExistentialAlways(ns)
+    // expected-error@-1 {{type 'NotSendable' does not conform to the 'Sendable' protocol}}
+  }
+}