Align Sendable diagnostic behavior with incremental-adoption proposal.

Determine whether a particular missing Sendable diagnostic should be
emitted as a warning or error, or even ignored entirely, based on the
emerging rules from the proposal for incremental adoption of Sendable
checking.

Author: DougGregor

lib/Sema/TypeCheckAvailability.cpp

@@ -3526,9 +3526,9 @@ void swift::diagnoseTypeAvailability(const TypeRepr *TR, Type T, SourceLoc loc,
 }
 
 static void diagnoseMissingConformance(
-    SourceLoc loc, Type type, ProtocolDecl *proto, ModuleDecl *module) {
+    SourceLoc loc, Type type, ProtocolDecl *proto, const DeclContext *fromDC) {
   assert(proto->isSpecificProtocol(KnownProtocolKind::Sendable));
-  diagnoseMissingSendableConformance(loc, type, module);
+  diagnoseMissingSendableConformance(loc, type, fromDC);
 }
 
 bool
@@ -3546,16 +3546,14 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
 
   // Diagnose "missing" conformances where we needed a conformance but
   // didn't have one.
+  auto *DC = where.getDeclContext();
   if (auto builtinConformance = dyn_cast<BuiltinProtocolConformance>(rootConf)){
     if (builtinConformance->isMissing()) {
       diagnoseMissingConformance(loc, builtinConformance->getType(),
-                                 builtinConformance->getProtocol(),
-                                 where.getDeclContext()->getParentModule());
+                                 builtinConformance->getProtocol(), DC);
     }
   }
 
-  auto *DC = where.getDeclContext();
-
   auto maybeEmitAssociatedTypeNote = [&]() {
     if (!depTy && !replacementTy)
       return;

lib/Sema/TypeCheckConcurrency.cpp

@@ -601,46 +601,96 @@ static bool hasUnavailableConformance(ProtocolConformanceRef conformance) {
   return false;
 }
 
+static bool shouldDiagnoseExistingDataRaces(const DeclContext *dc) {
+  if (dc->getParentModule()->isConcurrencyChecked())
+    return true;
+
+  return contextUsesConcurrencyFeatures(dc);
+}
+
+/// Determine the default diagnostic behavior for this language mode.
+static DiagnosticBehavior defaultSendableDiagnosticBehavior(
+    const LangOptions &langOpts) {
+  // Prior to Swift 6, all Sendable-related diagnostics are warnings.
+  if (!langOpts.isSwiftVersionAtLeast(6))
+    return DiagnosticBehavior::Warning;
+
+  return DiagnosticBehavior::Unspecified;
+}
+
+DiagnosticBehavior SendableCheckContext::defaultDiagnosticBehavior() const {
+  // If we're not supposed to diagnose existing data races from this context,
+  // ignore the diagnostic entirely.
+  if (!shouldDiagnoseExistingDataRaces(fromDC))
+    return DiagnosticBehavior::Ignore;
+
+  return defaultSendableDiagnosticBehavior(fromDC->getASTContext().LangOpts);
+}
+
+/// Determine the diagnostic behavior for a Sendable reference to the given
+/// nominal type.
+DiagnosticBehavior SendableCheckContext::diagnosticBehavior(
+    NominalTypeDecl *nominal) const {
+  // Determine whether the type was explicitly non-Sendable.
+  auto nominalModule = nominal->getParentModule();
+  bool isExplicitlyNonSendable = nominalModule->isConcurrencyChecked();
+
+  // If we are performing an explicit conformance check, always consider this
+  // to be an explicitly non-Sendable type.
+  if (conformanceCheck) {
+    switch (*conformanceCheck) {
+    case SendableCheck::Explicit:
+      isExplicitlyNonSendable = true;
+      break;
+
+    case SendableCheck::ImpliedByStandardProtocol:
+    case SendableCheck::Implicit:
+      break;
+    }
+  }
+
+  // Determine whether this nominal type is visible via a @_predatesConcurrency
+  // import.
+  ImportDecl *predatesConcurrencyImport = nullptr;
+
+  // When the type is explicitly non-Sendable...
+  if (isExplicitlyNonSendable) {
+    // @_predatesConcurrency imports downgrade the diagnostic to a warning.
+    if (predatesConcurrencyImport) {
+      // FIXME: Note that this @_predatesConcurrency import was "used".
+      return DiagnosticBehavior::Warning;
+    }
+
+    return defaultSendableDiagnosticBehavior(fromDC->getASTContext().LangOpts);
+  }
+
+  // When the type is implicitly non-Sendable...
+
+  // @_predatesConcurrency always suppresses the diagnostic.
+  if (predatesConcurrencyImport) {
+    // FIXME: Note that this @_predatesConcurrency import was "used".
+    return DiagnosticBehavior::Ignore;
+  }
+
+  return defaultDiagnosticBehavior();
+}
+
 /// Produce a diagnostic for a single instance of a non-Sendable type where
 /// a Sendable type is required.
 static bool diagnoseSingleNonSendableType(
-    Type type, ModuleDecl *module, SourceLoc loc,
+    Type type, SendableCheckContext fromContext, SourceLoc loc,
     llvm::function_ref<
       std::pair<DiagnosticBehavior, bool>(Type, DiagnosticBehavior)> diagnose) {
 
   auto behavior = DiagnosticBehavior::Unspecified;
 
+  auto module = fromContext.fromDC->getParentModule();
   ASTContext &ctx = module->getASTContext();
   auto nominal = type->getAnyNominal();
-  const LangOptions &langOpts = ctx.LangOpts;
   if (nominal) {
-    // A nominal type that has not provided conformance to Sendable will be
-    // diagnosed based on whether its defining module was consistently
-    // checked for concurrency.
-    auto nominalModule = nominal->getParentModule();
-
-    if (langOpts.isSwiftVersionAtLeast(6)) {
-      // In Swift 6, error when the nominal type comes from a module that
-      // had the concurrency checks consistently applied or from this module.
-      // Otherwise, warn.
-      if (nominalModule->isConcurrencyChecked() || nominalModule == module)
-        behavior = DiagnosticBehavior::Unspecified;
-      else
-        behavior = DiagnosticBehavior::Warning;
-    } else {
-      // In Swift 5, warn if either the imported or importing model is
-      // checking for concurrency, or if the nominal type comes from this
-      // module. Otherwise, leave a safety hole.
-      if (nominalModule->isConcurrencyChecked() ||
-          nominalModule == module ||
-          langOpts.WarnConcurrency)
-        behavior = DiagnosticBehavior::Warning;
-      else
-        behavior = DiagnosticBehavior::Ignore;
-    }
-  } else if (!langOpts.isSwiftVersionAtLeast(6)) {
-    // Always warn in Swift 5.
-    behavior = DiagnosticBehavior::Warning;
+    behavior = fromContext.diagnosticBehavior(nominal);
+  } else {
+    behavior = fromContext.defaultDiagnosticBehavior();
   }
 
   DiagnosticBehavior actualBehavior;
@@ -667,9 +717,11 @@ static bool diagnoseSingleNonSendableType(
 }
 
 bool swift::diagnoseNonSendableTypes(
-    Type type, ModuleDecl *module, SourceLoc loc,
+    Type type, SendableCheckContext fromContext, SourceLoc loc,
     llvm::function_ref<
       std::pair<DiagnosticBehavior, bool>(Type, DiagnosticBehavior)> diagnose) {
+  auto module = fromContext.fromDC->getParentModule();
+
   // If the Sendable protocol is missing, do nothing.
   auto proto = module->getASTContext().getProtocol(KnownProtocolKind::Sendable);
   if (!proto)
@@ -678,15 +730,15 @@ bool swift::diagnoseNonSendableTypes(
   // FIXME: More detail for unavailable conformances.
   auto conformance = TypeChecker::conformsToProtocol(type, proto, module);
   if (conformance.isInvalid() || hasUnavailableConformance(conformance)) {
-    return diagnoseSingleNonSendableType(type, module, loc, diagnose);
+    return diagnoseSingleNonSendableType(type, fromContext, loc, diagnose);
   }
 
   // Walk the conformance, diagnosing any missing Sendable conformances.
   bool anyMissing = false;
   conformance.forEachMissingConformance(module,
       [&](BuiltinProtocolConformance *missing) {
         if (diagnoseSingleNonSendableType(
-                missing->getType(), module, loc, diagnose)) {
+                missing->getType(), fromContext, loc, diagnose)) {
           anyMissing = true;
         }
 
@@ -697,23 +749,23 @@ bool swift::diagnoseNonSendableTypes(
 }
 
 bool swift::diagnoseNonSendableTypesInReference(
-    ConcreteDeclRef declRef, ModuleDecl *module, SourceLoc loc,
+    ConcreteDeclRef declRef, const DeclContext *fromDC, SourceLoc loc,
     ConcurrentReferenceKind refKind) {
   // For functions, check the parameter and result types.
   SubstitutionMap subs = declRef.getSubstitutions();
   if (auto function = dyn_cast<AbstractFunctionDecl>(declRef.getDecl())) {
     for (auto param : *function->getParameters()) {
       Type paramType = param->getInterfaceType().subst(subs);
       if (diagnoseNonSendableTypes(
-              paramType, module, loc, diag::non_sendable_param_type))
+              paramType, fromDC, loc, diag::non_sendable_param_type))
         return true;
     }
 
     // Check the result type of a function.
     if (auto func = dyn_cast<FuncDecl>(function)) {
       Type resultType = func->getResultInterfaceType().subst(subs);
       if (diagnoseNonSendableTypes(
-              resultType, module, loc, diag::non_sendable_result_type))
+              resultType, fromDC, loc, diag::non_sendable_result_type))
         return true;
     }
 
@@ -725,7 +777,7 @@ bool swift::diagnoseNonSendableTypesInReference(
         ? var->getType()
         : var->getValueInterfaceType().subst(subs);
     if (diagnoseNonSendableTypes(
-            propertyType, module, loc,
+            propertyType, fromDC, loc,
             diag::non_sendable_property_type,
             var->getDescriptiveKind(), var->getName(),
             var->isLocalCapture()))
@@ -736,14 +788,14 @@ bool swift::diagnoseNonSendableTypesInReference(
     for (auto param : *subscript->getIndices()) {
       Type paramType = param->getInterfaceType().subst(subs);
       if (diagnoseNonSendableTypes(
-              paramType, module, loc, diag::non_sendable_param_type))
+              paramType, fromDC, loc, diag::non_sendable_param_type))
         return true;
     }
 
     // Check the element type of a subscript.
     Type resultType = subscript->getElementInterfaceType().subst(subs);
     if (diagnoseNonSendableTypes(
-            resultType, module, loc, diag::non_sendable_result_type))
+            resultType, fromDC, loc, diag::non_sendable_result_type))
       return true;
 
     return false;
@@ -753,9 +805,9 @@ bool swift::diagnoseNonSendableTypesInReference(
 }
 
 void swift::diagnoseMissingSendableConformance(
-    SourceLoc loc, Type type, ModuleDecl *module) {
+    SourceLoc loc, Type type, const DeclContext *fromDC) {
   diagnoseNonSendableTypes(
-      type, module, loc, diag::non_sendable_type);
+      type, fromDC, loc, diag::non_sendable_type);
 }
 
 namespace {
@@ -1893,7 +1945,7 @@ namespace {
         // Check for non-sendable types.
         bool problemFound =
             diagnoseNonSendableTypesInReference(
-              concDeclRef, getDeclContext()->getParentModule(), declLoc,
+              concDeclRef, getDeclContext(), declLoc,
               ConcurrentReferenceKind::SynchronousAsAsyncCall);
         if (problemFound)
           result = AsyncMarkingResult::NotSendable;
@@ -2023,14 +2075,14 @@ namespace {
       for (const auto &param : fnType->getParams()) {
         // FIXME: Dig out the locations of the corresponding arguments.
         if (diagnoseNonSendableTypes(
-                param.getParameterType(), getParentModule(), apply->getLoc(),
+                param.getParameterType(), getDeclContext(), apply->getLoc(),
                 diag::non_sendable_param_type))
           return true;
       }
 
       // Check for sendability of the result type.
       if (diagnoseNonSendableTypes(
-             fnType->getResult(), getParentModule(), apply->getLoc(),
+             fnType->getResult(), getDeclContext(), apply->getLoc(),
              diag::non_sendable_result_type))
         return true;
 
@@ -2056,7 +2108,7 @@ namespace {
       // A cross-actor access requires types to be concurrent-safe.
       if (isCrossActor) {
         return diagnoseNonSendableTypesInReference(
-            valueRef, getParentModule(), loc,
+            valueRef, getDeclContext(), loc,
             ConcurrentReferenceKind::CrossActor);
       }
 
@@ -2174,7 +2226,7 @@ namespace {
             (ctx.LangOpts.EnableExperimentalFlowSensitiveConcurrentCaptures &&
              parent.dyn_cast<LoadExpr *>())) {
           return diagnoseNonSendableTypesInReference(
-              valueRef, getParentModule(), loc,
+              valueRef, getDeclContext(), loc,
               ConcurrentReferenceKind::LocalCapture);
         }
 
@@ -2226,7 +2278,7 @@ namespace {
             auto type = component.getComponentType();
             if (shouldDiagnoseExistingDataRaces(getDeclContext()) &&
                 diagnoseNonSendableTypes(
-                    type, getParentModule(), component.getLoc(),
+                    type, getDeclContext(), component.getLoc(),
                     diag::non_sendable_keypath_access))
               return true;
 
@@ -2293,7 +2345,7 @@ namespace {
             if (type &&
                 shouldDiagnoseExistingDataRaces(getDeclContext()) &&
                 diagnoseNonSendableTypes(
-                    type, getParentModule(), component.getLoc(),
+                    type, getDeclContext(), component.getLoc(),
                     diag::non_sendable_keypath_capture))
               diagnosed = true;
           }
@@ -2399,7 +2451,7 @@ namespace {
         }
 
         return diagnoseNonSendableTypesInReference(
-            memberRef, getDeclContext()->getParentModule(), memberLoc,
+            memberRef, getDeclContext(), memberLoc,
             ConcurrentReferenceKind::CrossActor);
       }
 
@@ -3172,9 +3224,8 @@ ActorIsolation ActorIsolationRequest::evaluate(
         subs = genericEnv->getForwardingSubstitutionMap();
       }
       diagnoseNonSendableTypesInReference(
-          ConcreteDeclRef(value, subs),
-          value->getDeclContext()->getParentModule(), value->getLoc(),
-          ConcurrentReferenceKind::Nonisolated);
+          ConcreteDeclRef(value, subs), value->getDeclContext(),
+          value->getLoc(), ConcurrentReferenceKind::Nonisolated);
     }
 
     // Classes with global actors have additional rules regarding inheritance.
@@ -3589,13 +3640,6 @@ bool swift::contextUsesConcurrencyFeatures(const DeclContext *dc) {
   return false;
 }
 
-static bool shouldDiagnoseExistingDataRaces(const DeclContext *dc) {
-  if (dc->getParentModule()->isConcurrencyChecked())
-    return true;
-
-  return contextUsesConcurrencyFeatures(dc);
-}
-
 /// Limit the diagnostic behavior used when performing checks for the Sendable
 /// instance storage of Sendable types.
 ///
@@ -3718,7 +3762,7 @@ static bool checkSendableInstanceStorage(
 
       // Check that the property type is Sendable.
       bool diagnosedProperty = diagnoseNonSendableTypes(
-          propertyType, dc->getParentModule(), property->getLoc(),
+          propertyType, SendableCheckContext(dc, check), property->getLoc(),
           [&](Type type, DiagnosticBehavior suggestedBehavior) {
             auto action = limitSendableInstanceBehavior(
                 langOpts, check, suggestedBehavior);
@@ -3748,7 +3792,7 @@ static bool checkSendableInstanceStorage(
     /// Handle an enum associated value.
     bool operator()(EnumElementDecl *element, Type elementType) {
       bool diagnosedElement = diagnoseNonSendableTypes(
-          elementType, dc->getParentModule(), element->getLoc(),
+          elementType, SendableCheckContext(dc, check), element->getLoc(),
           [&](Type type, DiagnosticBehavior suggestedBehavior) {
             auto action = limitSendableInstanceBehavior(
                 langOpts, check, suggestedBehavior);