[Concurrency] Downgrade @preconcurrency conformance requirement failures to

warnings in Swift 6 mode.

(cherry picked from commit e21bf2f)

Author: hborla

lib/Sema/TypeCheckAvailability.cpp

@@ -3875,8 +3875,12 @@ bool ExprAvailabilityWalker::diagnoseDeclRefAvailability(
       return true;
 
   if (R.isValid()) {
-    if (diagnoseSubstitutionMapAvailability(R.Start, declRef.getSubstitutions(),
-                                            Where)) {
+    if (diagnoseSubstitutionMapAvailability(
+            R.Start, declRef.getSubstitutions(), Where,
+            Type(), Type(),
+            /*warnIfConformanceUnavailablePreSwift6*/false,
+            /*suppressParameterizationCheckForOptional*/false,
+            /*preconcurrency*/D->preconcurrency())) {
       return true;
     }
   }
@@ -4348,7 +4352,8 @@ class ProblematicTypeFinder : public TypeDeclFinder {
         /*depTy=*/Type(),
         /*replacementTy=*/Type(),
         /*warnIfConformanceUnavailablePreSwift6=*/false,
-        /*suppressParameterizationCheckForOptional=*/ty->isOptional());
+        /*suppressParameterizationCheckForOptional=*/ty->isOptional(),
+        /*preconcurrency*/ty->getAnyNominal()->preconcurrency());
     return Action::Continue;
   }
 
@@ -4403,17 +4408,19 @@ void swift::diagnoseTypeAvailability(const TypeRepr *TR, Type T, SourceLoc loc,
 }
 
 static void diagnoseMissingConformance(
-    SourceLoc loc, Type type, ProtocolDecl *proto, const DeclContext *fromDC) {
+    SourceLoc loc, Type type, ProtocolDecl *proto, const DeclContext *fromDC,
+    bool preconcurrency) {
   assert(proto->isSpecificProtocol(KnownProtocolKind::Sendable));
-  diagnoseMissingSendableConformance(loc, type, fromDC);
+  diagnoseMissingSendableConformance(loc, type, fromDC, preconcurrency);
 }
 
 bool
 swift::diagnoseConformanceAvailability(SourceLoc loc,
                                        ProtocolConformanceRef conformance,
                                        const ExportContext &where,
                                        Type depTy, Type replacementTy,
-                                       bool warnIfConformanceUnavailablePreSwift6) {
+                                       bool warnIfConformanceUnavailablePreSwift6,
+                                       bool preconcurrency) {
   assert(!where.isImplicit());
 
   if (conformance.isInvalid() || conformance.isAbstract())
@@ -4425,7 +4432,8 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
     for (auto patternConf : pack->getPatternConformances()) {
       diagnosed |= diagnoseConformanceAvailability(
           loc, patternConf, where, depTy, replacementTy,
-          warnIfConformanceUnavailablePreSwift6);
+          warnIfConformanceUnavailablePreSwift6,
+          preconcurrency);
     }
     return diagnosed;
   }
@@ -4444,7 +4452,8 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
   if (auto builtinConformance = dyn_cast<BuiltinProtocolConformance>(rootConf)){
     if (builtinConformance->isMissing()) {
       diagnoseMissingConformance(loc, builtinConformance->getType(),
-                                 builtinConformance->getProtocol(), DC);
+                                 builtinConformance->getProtocol(), DC,
+                                 preconcurrency);
     }
   }
 
@@ -4498,7 +4507,8 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
   SubstitutionMap subConformanceSubs = concreteConf->getSubstitutionMap();
   if (diagnoseSubstitutionMapAvailability(loc, subConformanceSubs, where,
                                           depTy, replacementTy,
-                                          warnIfConformanceUnavailablePreSwift6))
+                                          warnIfConformanceUnavailablePreSwift6,
+                                          preconcurrency))
     return true;
 
   return false;
@@ -4510,12 +4520,14 @@ swift::diagnoseSubstitutionMapAvailability(SourceLoc loc,
                                            const ExportContext &where,
                                            Type depTy, Type replacementTy,
                                            bool warnIfConformanceUnavailablePreSwift6,
-                                           bool suppressParameterizationCheckForOptional) {
+                                           bool suppressParameterizationCheckForOptional,
+                                           bool preconcurrency) {
   bool hadAnyIssues = false;
   for (ProtocolConformanceRef conformance : subs.getConformances()) {
     if (diagnoseConformanceAvailability(loc, conformance, where,
                                         depTy, replacementTy,
-                                        warnIfConformanceUnavailablePreSwift6))
+                                        warnIfConformanceUnavailablePreSwift6,
+                                        preconcurrency))
       hadAnyIssues = true;
   }
 

lib/Sema/TypeCheckAvailability.h

@@ -228,7 +228,8 @@ diagnoseConformanceAvailability(SourceLoc loc,
                                 const ExportContext &context,
                                 Type depTy=Type(),
                                 Type replacementTy=Type(),
-                                bool warnIfConformanceUnavailablePreSwift6 = false);
+                                bool warnIfConformanceUnavailablePreSwift6 = false,
+                                bool preconcurrency = false);
 
 bool diagnoseSubstitutionMapAvailability(
     SourceLoc loc,
@@ -237,7 +238,8 @@ bool diagnoseSubstitutionMapAvailability(
     Type depTy = Type(),
     Type replacementTy = Type(),
     bool warnIfConformanceUnavailablePreSwift6 = false,
-    bool suppressParameterizationCheckForOptional = false);
+    bool suppressParameterizationCheckForOptional = false,
+    bool preconcurrency = false);
 
 /// Diagnose uses of unavailable declarations. Returns true if a diagnostic
 /// was emitted.

lib/Sema/TypeCheckConcurrency.cpp

@@ -1233,9 +1233,10 @@ bool swift::diagnoseNonSendableTypesInReference(
 }
 
 void swift::diagnoseMissingSendableConformance(
-    SourceLoc loc, Type type, const DeclContext *fromDC) {
+    SourceLoc loc, Type type, const DeclContext *fromDC, bool preconcurrency) {
+  SendableCheckContext sendableContext(fromDC, preconcurrency);
   diagnoseNonSendableTypes(
-      type, fromDC, /*inDerivedConformance*/Type(),
+      type, sendableContext, /*inDerivedConformance*/Type(),
       loc, diag::non_sendable_type);
 }
 

lib/Sema/TypeCheckConcurrency.h

@@ -320,7 +320,7 @@ bool diagnoseNonSendableTypesInReference(
 
 /// Produce a diagnostic for a missing conformance to Sendable.
 void diagnoseMissingSendableConformance(
-    SourceLoc loc, Type type, const DeclContext *fromDC);
+    SourceLoc loc, Type type, const DeclContext *fromDC, bool preconcurrency);
 
 /// If the given nominal type is public and does not explicitly
 /// state whether it conforms to Sendable, provide a diagnostic.

test/Concurrency/predates_concurrency_swift6.swift

@@ -173,3 +173,19 @@ func conversionDowngrade() {
   withSendableClosure(ns)
   // expected-warning@-1 {{converting non-sendable function value to '@Sendable () -> Void' may introduce data races}}
 }
+
+@preconcurrency
+func requireSendable<T: Sendable>(_: T) {}
+
+@preconcurrency
+struct RequireSendable<T: Sendable> {}
+
+class NotSendable {} // expected-note 2 {{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}}
+
+func testRequirementDowngrade(ns: NotSendable) {
+  requireSendable(ns)
+  // expected-warning@-1 {{type 'NotSendable' does not conform to the 'Sendable' protocol}}
+}

test/Concurrency/sendable_objc_attr_in_type_context_swift6.swift

@@ -104,13 +104,13 @@ func test_sendable_attr_in_type_context(test: Test) {
 
   // TOOD(diagnostics): Duplicate diagnostics
   TestWithSendableID().add(MyValue())
-  // expected-error@-1 3 {{type 'MyValue' does not conform to the 'Sendable' protocol}}
+  // expected-warning@-1 3 {{type 'MyValue' does not conform to the 'Sendable' protocol}}
 
   TestWithSendableSuperclass().add(SendableMyValue()) // Ok
 
   // TOOD(diagnostics): Duplicate diagnostics
   TestWithSendableSuperclass().add(MyValue())
-  // expected-error@-1 3 {{type 'MyValue' does not conform to the 'Sendable' protocol}}
+  // expected-warning@-1 3 {{type 'MyValue' does not conform to the 'Sendable' protocol}}
 }
 
 class TestConformanceWithStripping : InnerSendableTypes {