Downgrade sendability errors to warnings when they involve non-Sendable metatypes

The introduction of non-Sendable metatypes in Swift 6.2 (via SE-0470)
will break some existing Swift 6 code. Downgrade concurrency errors
involving non-Sendable metatypes to warnings until some future
language mode to ease the transition.

Author: DougGregor

lib/AST/Type.cpp

@@ -5006,11 +5006,15 @@ StringRef swift::getNameForParamSpecifier(ParamSpecifier specifier) {
   llvm_unreachable("bad ParamSpecifier");
 }
 
-std::optional<DiagnosticBehavior>
-TypeBase::getConcurrencyDiagnosticBehaviorLimit(DeclContext *declCtx) const {
-  auto *self = const_cast<TypeBase *>(this);
+static std::optional<DiagnosticBehavior>
+getConcurrencyDiagnosticBehaviorLimitRec(
+    Type type, DeclContext *declCtx,
+    llvm::SmallPtrSetImpl<NominalTypeDecl *> &visited) {
+  if (auto *nomDecl = type->getNominalOrBoundGenericNominal()) {
+    // If we have already seen this type, treat it as having no limit.
+    if (!visited.insert(nomDecl).second)
+      return std::nullopt;
 
-  if (auto *nomDecl = self->getNominalOrBoundGenericNominal()) {
     // First try to just grab the exact concurrency diagnostic behavior.
     if (auto result =
             swift::getConcurrencyDiagnosticBehaviorLimit(nomDecl, declCtx)) {
@@ -5021,11 +5025,12 @@ TypeBase::getConcurrencyDiagnosticBehaviorLimit(DeclContext *declCtx) const {
     // merging our fields if we have a struct.
     if (auto *structDecl = dyn_cast<StructDecl>(nomDecl)) {
       std::optional<DiagnosticBehavior> diagnosticBehavior;
-      auto substMap = self->getContextSubstitutionMap();
+      auto substMap = type->getContextSubstitutionMap();
       for (auto storedProperty : structDecl->getStoredProperties()) {
         auto lhs = diagnosticBehavior.value_or(DiagnosticBehavior::Unspecified);
         auto astType = storedProperty->getInterfaceType().subst(substMap);
-        auto rhs = astType->getConcurrencyDiagnosticBehaviorLimit(declCtx);
+        auto rhs = getConcurrencyDiagnosticBehaviorLimitRec(astType, declCtx,
+                                                            visited);
         auto result = lhs.merge(rhs.value_or(DiagnosticBehavior::Unspecified));
         if (result != DiagnosticBehavior::Unspecified)
           diagnosticBehavior = result;
@@ -5036,21 +5041,36 @@ TypeBase::getConcurrencyDiagnosticBehaviorLimit(DeclContext *declCtx) const {
 
   // When attempting to determine the diagnostic behavior limit of a tuple, just
   // merge for each of the elements.
-  if (auto *tupleType = self->getAs<TupleType>()) {
+  if (auto *tupleType = type->getAs<TupleType>()) {
     std::optional<DiagnosticBehavior> diagnosticBehavior;
     for (auto tupleType : tupleType->getElements()) {
       auto lhs = diagnosticBehavior.value_or(DiagnosticBehavior::Unspecified);
 
       auto type = tupleType.getType()->getCanonicalType();
-      auto rhs = type->getConcurrencyDiagnosticBehaviorLimit(declCtx);
+      auto rhs = getConcurrencyDiagnosticBehaviorLimitRec(type, declCtx,
+                                                          visited);
       auto result = lhs.merge(rhs.value_or(DiagnosticBehavior::Unspecified));
       if (result != DiagnosticBehavior::Unspecified)
         diagnosticBehavior = result;
     }
     return diagnosticBehavior;
   }
 
-  return {};
+  // Metatypes that aren't Sendable were introduced in Swift 6.2, so downgrade
+  // them to warnings prior to Swift 7.
+  if (type->is<AnyMetatypeType>()) {
+    if (!type->getASTContext().LangOpts.isSwiftVersionAtLeast(7))
+      return DiagnosticBehavior::Warning;
+  }
+
+  return std::nullopt;
+}
+
+std::optional<DiagnosticBehavior>
+TypeBase::getConcurrencyDiagnosticBehaviorLimit(DeclContext *declCtx) const {
+  auto *self = const_cast<TypeBase *>(this);
+  llvm::SmallPtrSet<NominalTypeDecl *, 16> visited;
+  return getConcurrencyDiagnosticBehaviorLimitRec(Type(self), declCtx, visited);
 }
 
 GenericTypeParamKind

lib/Sema/TypeCheckConcurrency.cpp

@@ -878,6 +878,12 @@ SendableCheckContext::preconcurrencyBehavior(
   return std::nullopt;
 }
 
+std::optional<DiagnosticBehavior>
+SendableCheckContext::preconcurrencyBehavior(Type type) const {
+  return type->getConcurrencyDiagnosticBehaviorLimit(
+      const_cast<DeclContext *>(fromDC));
+}
+
 static bool shouldDiagnosePreconcurrencyImports(SourceFile &sf) {
   switch (sf.Kind) {
   case SourceFileKind::Interface:
@@ -6671,8 +6677,7 @@ static bool checkSendableInstanceStorage(
           propertyType, context,
           /*inDerivedConformance*/Type(), property->getLoc(),
           [&](Type type, DiagnosticBehavior behavior) {
-            auto preconcurrency =
-                context.preconcurrencyBehavior(type->getAnyNominal());
+            auto preconcurrency = context.preconcurrencyBehavior(type);
             if (isImplicitSendableCheck(check)) {
               // If this is for an externally-visible conformance, fail.
               if (check == SendableCheck::ImplicitForExternallyVisible) {

lib/Sema/TypeCheckConcurrency.h

@@ -407,10 +407,18 @@ struct SendableCheckContext {
   /// type in this context.
   DiagnosticBehavior diagnosticBehavior(NominalTypeDecl *nominal) const;
 
+  /// Determine the preconcurrency behavior when referencing the given
+  /// declaration from a type. This only has an effect when the declaration
+  /// is a nominal type.
   std::optional<DiagnosticBehavior> preconcurrencyBehavior(
       Decl *decl,
       bool ignoreExplicitConformance = false) const;
 
+  /// Determine the preconcurrency behavior when referencing the given
+  /// non-Sendable type. This only has an effect when the declaration
+  /// is a nominal or metatype type.
+  std::optional<DiagnosticBehavior> preconcurrencyBehavior(Type type) const;
+
   /// Whether to warn about a Sendable violation even in minimal checking.
   bool warnInMinimalChecking() const;
 };
@@ -460,8 +468,7 @@ bool diagnoseNonSendableTypes(
       [&](Type specificType, DiagnosticBehavior behavior) {
         // FIXME: Reconcile preconcurrency declaration vs preconcurrency
         // import behavior.
-        auto preconcurrency =
-          fromContext.preconcurrencyBehavior(specificType->getAnyNominal());
+        auto preconcurrency = fromContext.preconcurrencyBehavior(specificType);
 
         ctx.Diags.diagnose(diagnoseLoc, diag, type, diagArgs...)
             .limitBehaviorWithPreconcurrency(behavior,
@@ -497,8 +504,7 @@ bool diagnoseIfAnyNonSendableTypes(
   diagnoseNonSendableTypes(
       type, fromContext, derivedConformance, typeLoc,
       [&](Type specificType, DiagnosticBehavior behavior) {
-        auto preconcurrency =
-          fromContext.preconcurrencyBehavior(specificType->getAnyNominal());
+        auto preconcurrency = fromContext.preconcurrencyBehavior(specificType);
 
         if (behavior == DiagnosticBehavior::Ignore ||
             preconcurrency == DiagnosticBehavior::Ignore)

test/Concurrency/sendable_metatype.swift

@@ -19,14 +19,14 @@ func acceptMetaOnMainActor<T>(_: T.Type) { }
 // -------------------------------------------------------------------------
 nonisolated func staticCallThroughMetaSmuggled<T: Q>(_: T.Type) {
   let x: Q.Type = T.self
-  Task.detached { // expected-error{{risks causing data races}}
+  Task.detached { // expected-warning{{risks causing data races}}
     x.g() // expected-note{{closure captures 'x' which is accessible to code in the current task}}
   }
 }
 
 nonisolated func passMetaSmuggled<T: Q>(_: T.Type) {
   let x: Q.Type = T.self
-  Task.detached { // expected-error{{risks causing data races}}
+  Task.detached { // expected-warning{{risks causing data races}}
     acceptMeta(x) // expected-note{{closure captures 'x' which is accessible to code in the current task}}
   }
 }
@@ -79,7 +79,7 @@ nonisolated func passSendableToMainActorSmuggledAny<T: Sendable>(_: T.Type) asyn
 // -------------------------------------------------------------------------
 nonisolated func passMetaSmuggledAnyFromExistential(_ pqT: (P & Q).Type) {
   let x: P.Type = pqT
-  Task.detached { // expected-error{{passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure}}
+  Task.detached { // expected-warning{{passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure}}
     acceptMeta(x) // expected-note{{closure captures 'x' which is accessible to code in the current task}}
   }
 }

test/Concurrency/sendable_metatype_typecheck.swift

@@ -21,9 +21,9 @@ func testSendableExistential() {
 nonisolated func acceptMeta<T>(_: T.Type) { }
 
 nonisolated func staticCallThroughMetaVal<T: Q>(_: T.Type) {
-  let x = T.self // expected-error{{capture of non-sendable type 'T.Type' in an isolated closure}}
+  let x = T.self // expected-warning{{capture of non-sendable type 'T.Type' in an isolated closure}}
   Task.detached {
-    x.g() // expected-error{{capture of non-sendable type 'T.Type' in an isolated closure}}
+    x.g() // expected-warning{{capture of non-sendable type 'T.Type' in an isolated closure}}
   }
 }
 
@@ -35,21 +35,21 @@ nonisolated func captureThroughMetaValMoReqs<T>(_: T.Type) {
 }
 
 nonisolated func passMetaVal<T: Q>(_: T.Type) {
-  let x = T.self // expected-error{{capture of non-sendable type 'T.Type' in an isolated closure}}
+  let x = T.self // expected-warning{{capture of non-sendable type 'T.Type' in an isolated closure}}
   Task.detached {
-    acceptMeta(x) // expected-error{{capture of non-sendable type}}
+    acceptMeta(x) // expected-warning{{capture of non-sendable type}}
   }
 }
 
 nonisolated func staticCallThroughMeta<T: Q>(_: T.Type) {
   Task.detached {
-    T.g() // expected-error{{capture of non-sendable type}}
+    T.g() // expected-warning{{capture of non-sendable type}}
   }
 }
 
 nonisolated func passMeta<T: Q>(_: T.Type) {
   Task.detached {
-    acceptMeta(T.self) // expected-error{{capture of non-sendable type 'T.Type' in an isolated closure}}
+    acceptMeta(T.self) // expected-warning{{capture of non-sendable type 'T.Type' in an isolated closure}}
   }
 }
 
@@ -99,3 +99,21 @@ struct GenericThingy<Element> {
     let _: @Sendable (Element, Element) -> Bool = (>) // expected-error{{converting non-sendable function value to '@Sendable (Element, Element) -> Bool' may introduce data races}}
   }
 }
+
+extension Int: Q {
+  static func g() { }
+}
+
+extension String: Q {
+  static func g() { }
+}
+
+class Holder: @unchecked Sendable {
+  // expected-note@+3{{disable concurrency-safety checks if accesses are protected by an external synchronization mechanism}}
+  // expected-note@+2{{add '@MainActor' to make static property 'globalExistentialThing' part of global actor 'MainActor'}}
+  // expected-warning@+1{{static property 'globalExistentialThing' is not concurrency-safe because non-'Sendable' type 'Dictionary<Int, any Q.Type>' may have shared mutable state}}
+  static let globalExistentialThing: Dictionary<Int, Q.Type> = [
+    1: Int.self,
+    2: String.self,
+  ]
+}