Implement customizable Sendable conformance diagnostics.

Rework Sendable checking to be completely based on "missing"
conformances, so that we can individually diagnose missing Sendable
conformances based on both the module in which the conformance check
happened as well as where the type was declared. The basic rules here
are to only diagnose if either the module where the non-Sendable type
was declared or the module where it was checked was compiled with a
mode that consistently diagnoses `Sendable`, either by virtue of
being Swift 6 or because `-warn-concurrency` was provided on the
command line. And have that diagnostic be an error in Swift 6 or
warning in Swift 5.x.

There is much tuning to be done here.

Author: DougGregor

Diff for: include/swift/AST/Decl.h

@@ -598,7 +598,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasAnyUnavailableValues : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1+1,
     /// If the module is compiled as static library.
     StaticLibrary : 1,
 
@@ -633,7 +633,11 @@ class alignas(1 << DeclAlignInBits) Decl {
     IsMainModule : 1,
 
     /// Whether this module has incremental dependency information available.
-    HasIncrementalInfo : 1
+    HasIncrementalInfo : 1,
+
+    /// Whether this module has been compiled with comprehensive checking for
+    /// concurrency, e.g., Sendable checking.
+    IsConcurrencyChecked : 1
   );
 
   SWIFT_INLINE_BITFIELD(PrecedenceGroupDecl, Decl, 1+2,

Diff for: include/swift/AST/DiagnosticsSema.def

@@ -1939,6 +1939,9 @@ NOTE(nonsendable_function_type,none,
 NOTE(nonsendable_tuple_type,none,
      "a tuple type must be composed of 'Sendable' elements to conform to "
      "'Sendable'", ())
+NOTE(add_nominal_sendable_conformance,none,
+     "add conformance of %0 %1 to the 'Sendable' protocol",
+     (DescriptiveDeclKind, DeclName))
 
 NOTE(required_by_opaque_return,none,
     "required by opaque return type of %0 %1", (DescriptiveDeclKind, DeclName))
@@ -4492,20 +4495,20 @@ NOTE(protocol_isolated_to_global_actor_here,none,
 ERROR(isolated_parameter_not_actor,none,
       "'isolated' parameter has non-actor type %0", (Type))
 
-WARNING(non_concurrent_param_type,none,
+WARNING(non_sendable_param_type,none,
         "cannot pass argument of non-sendable type %0 across actors",
         (Type))
-WARNING(non_concurrent_result_type,none,
+WARNING(non_sendable_result_type,none,
         "cannot call function returning non-sendable type %0 across "
         "actors", (Type))
-WARNING(non_concurrent_property_type,none,
-        "cannot use %0 %1 with a non-sendable type %2 "
+WARNING(non_sendable_property_type,none,
+        "cannot use %1 %2 with a non-sendable type %0 "
         "%select{across actors|from concurrently-executed code}3",
-        (DescriptiveDeclKind, DeclName, Type, bool))
-WARNING(non_concurrent_keypath_capture,none,
+        (Type, DescriptiveDeclKind, DeclName, bool))
+WARNING(non_sendable_keypath_capture,none,
         "cannot form key path that captures non-sendable type %0",
         (Type))
-WARNING(non_concurrent_keypath_access,none,
+WARNING(non_sendable_keypath_access,none,
         "cannot form key path that accesses non-sendable type %0",
         (Type))
 ERROR(non_concurrent_type_member,none,
@@ -4528,9 +4531,6 @@ ERROR(concurrent_value_inherit,none,
       (bool, DeclName))
 ERROR(non_sendable_type,none,
       "type %0 does not conform to the 'Sendable' protocol", (Type))
-ERROR(non_sendable_function_type,none,
-     "function type %0 must be marked '@Sendable' to conform to 'Sendable'",
-      (Type))
 
 WARNING(unchecked_conformance_not_special,none,
       "@unchecked conformance to %0 has no meaning", (Type))

Diff for: include/swift/AST/Module.h

@@ -513,6 +513,16 @@ class ModuleDecl : public DeclContext, public TypeDecl {
     return Bits.ModuleDecl.IsMainModule;
   }
 
+  /// Whether this module has been compiled with comprehensive checking for
+  /// concurrency, e.g., Sendable checking.
+  bool isConcurrencyChecked() const {
+    return Bits.ModuleDecl.IsConcurrencyChecked;
+  }
+
+  void setIsConcurrencyChecked(bool value = true) {
+    Bits.ModuleDecl.IsConcurrencyChecked = value;
+  }
+
   /// For the main module, retrieves the list of primary source files being
   /// compiled, that is, the files we're generating code for.
   ArrayRef<SourceFile *> getPrimarySourceFiles() const;

Diff for: include/swift/AST/ProtocolConformanceRef.h

@@ -19,6 +19,8 @@
 #include "swift/Basic/Debug.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/ADT/STLExtras.h"
+#include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/Requirement.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/AST/Type.h"
@@ -29,6 +31,7 @@ namespace llvm {
 
 namespace swift {
 
+class BuiltinProtocolConformance;
 class ConcreteDeclRef;
 class ProtocolConformance;
 enum class EffectKind : uint8_t;
@@ -72,6 +75,11 @@ class ProtocolConformanceRef {
     return ProtocolConformanceRef();
   }
 
+  /// Retrieve an invalid or missing conformance, as appropriate, when a
+  /// legitimate conformance doesn't exist.
+  static ProtocolConformanceRef forMissingOrInvalid(
+      Type type, ProtocolDecl *proto);
+
   bool isInvalid() const {
     return !Union;
   }
@@ -103,6 +111,19 @@ class ProtocolConformanceRef {
   /// cannot be depended on to always exist.
   bool hasMissingConformance(ModuleDecl *module) const;
 
+  /// Enumerate the missing conformances in this conformance.
+  ///
+  /// Calls \c fn with each missing conformance found within this conformance,
+  /// including this conformance or any conditional conformances it depends on.
+  /// If the invocation of \c fn returns \c true, the traversal exits early
+  /// and the overall function returns \c true.
+  ///
+  /// \returns \c true if any invocation of \c fn returned true,
+  /// \c false otherwise.
+  bool forEachMissingConformance(
+      ModuleDecl *module,
+      llvm::function_ref<bool(BuiltinProtocolConformance *missing)> fn) const;
+
   using OpaqueValue = void*;
   OpaqueValue getOpaqueValue() const { return Union.getOpaqueValue(); }
   static ProtocolConformanceRef getFromOpaqueValue(OpaqueValue value) {

Diff for: include/swift/Option/Options.td

@@ -659,7 +659,7 @@ def warn_swift3_objc_inference : Flag<["-"], "warn-swift3-objc-inference">,
   Flags<[FrontendOption, DoesNotAffectIncrementalBuild, HelpHidden]>;
 
 def warn_concurrency : Flag<["-"], "warn-concurrency">,
-  Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
+  Flags<[FrontendOption, DoesNotAffectIncrementalBuild, ModuleInterfaceOptionIgnorable]>,
   HelpText<"Warn about code that is unsafe according to the Swift Concurrency "
            "model and will become ill-formed in a future language version">;
 

Diff for: include/swift/Serialization/Validation.h

@@ -103,6 +103,7 @@ class ExtendedValidationInfo {
     unsigned ResilienceStrategy : 2;
     unsigned IsImplicitDynamicEnabled : 1;
     unsigned IsAllowModuleWithCompilerErrorsEnabled : 1;
+    unsigned IsConcurrencyChecked : 1;
   } Bits;
 public:
   ExtendedValidationInfo() : Bits() {}
@@ -155,6 +156,13 @@ class ExtendedValidationInfo {
 
   StringRef getModuleABIName() const { return ModuleABIName; }
   void setModuleABIName(StringRef name) { ModuleABIName = name; }
+
+  bool isConcurrencyChecked() const {
+    return Bits.IsConcurrencyChecked;
+  }
+  void setIsConcurrencyChecked(bool val = true) {
+    Bits.IsConcurrencyChecked = val;
+  }
 };
 
 /// Returns info about the serialized AST in the given data.

Diff for: lib/AST/GenericSignature.cpp

@@ -458,7 +458,7 @@ GenericSignatureImpl::lookupConformance(CanType type,
   if (type->isTypeParameter())
     return ProtocolConformanceRef(proto);
 
-  return M->lookupConformance(type, proto);
+  return M->lookupConformance(type, proto, /*allowMissing=*/true);
 }
 
 bool GenericSignatureImpl::requiresClass(Type type) const {

Diff for: lib/AST/Module.cpp

@@ -489,6 +489,7 @@ ModuleDecl::ModuleDecl(Identifier name, ASTContext &ctx,
   Bits.ModuleDecl.IsNonSwiftModule = 0;
   Bits.ModuleDecl.IsMainModule = 0;
   Bits.ModuleDecl.HasIncrementalInfo = 0;
+  Bits.ModuleDecl.IsConcurrencyChecked = 0;
 }
 
 ImplicitImportList ModuleDecl::getImplicitImports() const {
@@ -978,6 +979,21 @@ static bool shouldCreateMissingConformances(ProtocolDecl *proto) {
   return proto->isSpecificProtocol(KnownProtocolKind::Sendable);
 }
 
+ProtocolConformanceRef ProtocolConformanceRef::forMissingOrInvalid(
+    Type type, ProtocolDecl *proto) {
+  // Introduce "missing" conformances when appropriate, so that type checking
+  // (and even code generation) can continue.
+  ASTContext &ctx = proto->getASTContext();
+  if (shouldCreateMissingConformances(proto)) {
+    return ProtocolConformanceRef(
+        ctx.getBuiltinConformance(
+          type, proto, GenericSignature(), { },
+          BuiltinConformanceKind::Missing));
+  }
+
+  return ProtocolConformanceRef::forInvalid();
+}
+
 ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
                                                      ProtocolDecl *protocol,
                                                      bool allowMissing) {
@@ -1007,23 +1023,6 @@ ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
   return result;
 }
 
-/// Retrieve an invalid or missing conformance, as appropriate, when a
-/// legitimate conformance doesn't exist.
-static ProtocolConformanceRef getInvalidOrMissingConformance(
-    Type type, ProtocolDecl *proto) {
-  // Introduce "missing" conformances when appropriate, so that type checking
-  // (and even code generation) can continue.
-  ASTContext &ctx = proto->getASTContext();
-  if (shouldCreateMissingConformances(proto)) {
-    return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(
-          type, proto, GenericSignature(), { },
-          BuiltinConformanceKind::Missing));
-  }
-
-  return ProtocolConformanceRef::forInvalid();
-}
-
 /// Synthesize a builtin tuple type conformance to the given protocol, if
 /// appropriate.
 static ProtocolConformanceRef getBuiltinTupleTypeConformance(
@@ -1083,7 +1082,7 @@ static ProtocolConformanceRef getBuiltinTupleTypeConformance(
         ctx.getSpecializedConformance(type, genericConformance, subMap));
   }
 
-  return getInvalidOrMissingConformance(type, protocol);
+  return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 }
 
 /// Whether the given function type conforms to Sendable.
@@ -1116,7 +1115,7 @@ static ProtocolConformanceRef getBuiltinFunctionTypeConformance(
                                   BuiltinConformanceKind::Synthesized));
   }
 
-  return getInvalidOrMissingConformance(type, protocol);
+  return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 }
 
 /// Synthesize a builtin metatype type conformance to the given protocol, if
@@ -1131,7 +1130,7 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
                                   BuiltinConformanceKind::Synthesized));
   }
 
-  return getInvalidOrMissingConformance(type, protocol);
+  return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 }
 
 /// Synthesize a builtin type conformance to the given protocol, if
@@ -1146,7 +1145,7 @@ static ProtocolConformanceRef getBuiltinBuiltinTypeConformance(
                                   BuiltinConformanceKind::Synthesized));
   }
 
-  return getInvalidOrMissingConformance(type, protocol);
+  return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 }
 
 ProtocolConformanceRef
@@ -1184,7 +1183,7 @@ LookupConformanceInModuleRequest::evaluate(
         return ProtocolConformanceRef(protocol);
     }
 
-    return getInvalidOrMissingConformance(type, protocol);
+    return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
   }
 
   // An existential conforms to a protocol if the protocol is listed in the
@@ -1193,7 +1192,7 @@ LookupConformanceInModuleRequest::evaluate(
   if (type->isExistentialType()) {
     auto result = mod->lookupExistentialConformance(type, protocol);
     if (result.isInvalid())
-      return getInvalidOrMissingConformance(type, protocol);
+      return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
     return result;
   }
 
@@ -1231,13 +1230,13 @@ LookupConformanceInModuleRequest::evaluate(
 
   // If we don't have a nominal type, there are no conformances.
   if (!nominal || isa<ProtocolDecl>(nominal))
-    return getInvalidOrMissingConformance(type, protocol);
+    return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 
   // Find the (unspecialized) conformance.
   SmallVector<ProtocolConformance *, 2> conformances;
   if (!nominal->lookupConformance(protocol, conformances)) {
     if (!protocol->isSpecificProtocol(KnownProtocolKind::Sendable))
-      return getInvalidOrMissingConformance(type, protocol);
+      return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 
     // Try to infer Sendable conformance.
     GetImplicitSendableRequest cvRequest{nominal};
@@ -1246,7 +1245,7 @@ LookupConformanceInModuleRequest::evaluate(
       conformances.clear();
       conformances.push_back(conformance);
     } else {
-      return getInvalidOrMissingConformance(type, protocol);
+      return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
     }
   }
 

Diff for: lib/AST/ProtocolConformance.cpp

@@ -1665,23 +1665,30 @@ SourceLoc swift::extractNearestSourceLoc(const ProtocolConformanceRef conformanc
 }
 
 bool ProtocolConformanceRef::hasMissingConformance(ModuleDecl *module) const {
+  return forEachMissingConformance(module,
+      [](BuiltinProtocolConformance *builtin) {
+        return true;
+      });
+}
+
+bool ProtocolConformanceRef::forEachMissingConformance(
+    ModuleDecl *module,
+    llvm::function_ref<bool(BuiltinProtocolConformance *missing)> fn) const {
   if (!isConcrete())
     return false;
 
-  // Is this a missing Sendable conformance?
-  const ProtocolConformance *concreteConf = getConcrete();
-  const RootProtocolConformance *rootConf = concreteConf->getRootConformance();
+  // Is this a missing conformance?
+  ProtocolConformance *concreteConf = getConcrete();
+  RootProtocolConformance *rootConf = concreteConf->getRootConformance();
   if (auto builtinConformance = dyn_cast<BuiltinProtocolConformance>(rootConf)){
-    if (builtinConformance->isMissing() && builtinConformance->getProtocol()->isSpecificProtocol(
-            KnownProtocolKind::Sendable)) {
+    if (builtinConformance->isMissing() && fn(builtinConformance))
       return true;
-    }
   }
 
   // Check conformances that are part of this conformance.
   auto subMap = concreteConf->getSubstitutions(module);
   for (auto conformance : subMap.getConformances()) {
-    if (conformance.hasMissingConformance(module))
+    if (conformance.forEachMissingConformance(module, fn))
       return true;
   }
 

Diff for: lib/AST/SubstitutionMap.cpp

@@ -365,8 +365,10 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
 
   // If the type doesn't conform to this protocol, the result isn't formed
   // from these requirements.
-  if (!genericSig->requiresProtocol(type, proto))
-    return ProtocolConformanceRef::forInvalid();
+  if (!genericSig->requiresProtocol(type, proto)) {
+    Type substType = type.subst(*this);
+    return ProtocolConformanceRef::forMissingOrInvalid(substType, proto);
+  }
 
   auto accessPath =
     genericSig->getConformanceAccessPath(type, proto);

Diff for: lib/Frontend/Frontend.cpp

@@ -975,6 +975,9 @@ ModuleDecl *CompilerInstance::getMainModule() const {
     }
     if (Invocation.getFrontendOptions().EnableLibraryEvolution)
       MainModule->setResilienceStrategy(ResilienceStrategy::Resilient);
+    if (Invocation.getLangOptions().WarnConcurrency ||
+        Invocation.getLangOptions().isSwiftVersionAtLeast(6))
+      MainModule->setIsConcurrencyChecked(true);
 
     // Register the main module with the AST context.
     Context->addLoadedModule(MainModule);

Diff for: lib/IDE/CodeCompletion.cpp

@@ -2627,7 +2627,6 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   void analyzeActorIsolation(const ValueDecl *VD, Type T, bool &implicitlyAsync,
                              Optional<NotRecommendedReason> &NotRecommended) {
     auto isolation = getActorIsolation(const_cast<ValueDecl *>(VD));
-    auto &ctx = VD->getASTContext();
 
     switch (isolation.getKind()) {
     case ActorIsolation::DistributedActorInstance: {
@@ -2646,7 +2645,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
       // if the context has adopted concurrency.
       if (!CanCurrDeclContextHandleAsync &&
           !completionContextUsesConcurrencyFeatures(CurrDeclContext) &&
-          !ctx.LangOpts.WarnConcurrency) {
+          !CurrDeclContext->getParentModule()->isConcurrencyChecked()) {
         return;
       }
       LLVM_FALLTHROUGH;
@@ -2664,7 +2663,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     }
 
     // If the reference is 'async', all types must be 'Sendable'.
-    if (ctx.LangOpts.WarnConcurrency && implicitlyAsync && T) {
+    if (CurrDeclContext->getParentModule()->isConcurrencyChecked() &&
+        implicitlyAsync && T) {
       auto *M = CurrDeclContext->getParentModule();
       if (isa<VarDecl>(VD)) {
         if (!isSendableType(M, T)) {