[SE-0302] Crank up Sendable to also diagnose in-module missing conformances.

Extend the diagnostics for `Sendable` conformances to always diagnose
missing `Sendable` conformances for nominal types that are within the
same module. The intuition here is that if the type is in the same
module, it can be updated and evaluated at the same time as code
requiring the `Sendable` conformance is introduced.

Another part of rdar://78269348.

Author: DougGregor

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(non_sendable_nominal,none,
+     "%0 %1 does not conform to the `Sendable` protocol",
+      (DescriptiveDeclKind, DeclName))
 NOTE(add_nominal_sendable_conformance,none,
      "consider making %0 %1 conform to the 'Sendable' protocol",
      (DescriptiveDeclKind, DeclName))

lib/Sema/TypeCheckConcurrency.cpp

@@ -583,30 +583,26 @@ static bool diagnoseSingleNonSendableType(
 
     if (langOpts.isSwiftVersionAtLeast(6)) {
       // In Swift 6, error when the nominal type comes from a module that
-      // had the concurrency checks consistently applied. Otherwise,
-      // warn only when requested (via -warn-concurrency) and leave a safety
-      // hole otherwise.
-      if (nominalModule->isConcurrencyChecked())
+      // had the concurrency checks consistently applied or from this module.
+      // Otherwise, warn.
+      if (nominalModule->isConcurrencyChecked() || nominalModule == module)
         behavior = DiagnosticBehavior::Unspecified;
-      else if (langOpts.WarnConcurrency)
-        behavior = DiagnosticBehavior::Warning;
       else
-        behavior = DiagnosticBehavior::Ignore;
+        behavior = DiagnosticBehavior::Warning;
     } else {
       // In Swift 5, warn if either the imported or importing model is
-      // checking for concurrency. Otherwise, leave a safety hole.
-      if (nominalModule->isConcurrencyChecked() || langOpts.WarnConcurrency)
+      // 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)) {
-    // In Swift 5, warn if the current module requested warnings. Otherwise,
-    // leave a safety hole.
-    if (langOpts.WarnConcurrency)
-      behavior = DiagnosticBehavior::Warning;
-    else
-      behavior = DiagnosticBehavior::Ignore;
+    // Always warn in Swift 5.
+    behavior = DiagnosticBehavior::Warning;
   }
 
   bool wasError = diagnose(type, behavior);
@@ -626,6 +622,10 @@ static bool diagnoseSingleNonSendableType(
       fixItLoc = Lexer::getLocForEndOfToken(ctx.SourceMgr, fixItLoc);
       note.fixItInsert(fixItLoc, ", Sendable");
     }
+  } else if (nominal) {
+    nominal->diagnose(
+        diag::non_sendable_nominal, nominal->getDescriptiveKind(),
+        nominal->getName());
   }
 
   return wasError;
@@ -2047,7 +2047,8 @@ namespace {
         if (auto varDecl = dyn_cast<VarDecl>(decl)) {
           if (varDecl->isLet()) {
             auto type = component.getComponentType();
-            if (diagnoseNonSendableTypes(
+            if (shouldDiagnoseExistingDataRaces(getDeclContext()) &&
+                diagnoseNonSendableTypes(
                     type, getParentModule(), component.getLoc(),
                     diag::non_sendable_keypath_access))
               return true;
@@ -2113,6 +2114,7 @@ namespace {
         if (auto indexExpr = component.getIndexExpr()) {
           auto type = indexExpr->getType();
           if (type &&
+              shouldDiagnoseExistingDataRaces(getDeclContext()) &&
               diagnoseNonSendableTypes(
                   type, getParentModule(), component.getLoc(),
                   diag::non_sendable_keypath_capture))

test/Concurrency/Inputs/NonStrictModule.swift

@@ -0,0 +1 @@
+public class NonStrictClass { }

test/Concurrency/Inputs/StrictModule.swift

@@ -0,0 +1 @@
+public struct StrictStruct: Hashable { }

test/Concurrency/actor_call_implicitly_async.swift

@@ -13,7 +13,7 @@ func rethrower(_ f : @autoclosure () throws -> Any) rethrows -> Any {
 func asAutoclosure(_ f : @autoclosure () -> Any) -> Any { return f() }
 
 // not a concurrency-safe type
-class Box {
+class Box { // expected-note 4{{class 'Box' does not conform to the `Sendable` protocol}}
   var counter : Int = 0
 }
 

test/Concurrency/actor_isolation.swift

@@ -46,7 +46,7 @@ actor MySuperActor {
   }
 }
 
-class Point {
+class Point { // expected-note{{class 'Point' does not conform to the `Sendable` protocol}}
   var x : Int = 0
   var y : Int = 0
 }

test/Concurrency/actor_isolation_unsafe.swift

@@ -34,7 +34,7 @@ struct S4_P1: P1 {
 }
 
 @MainActor(unsafe)
-protocol P2 {
+protocol P2 { // expected-note{{protocol 'P2' does not conform to the `Sendable` protocol}}
   func f() // expected-note{{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
   nonisolated func g()
 }
@@ -44,6 +44,7 @@ struct S5_P2: P2 {
   func g() { }
 }
 
+// expected-warning@+1{{cannot pass argument of non-sendable type 'P2' across actors}}
 nonisolated func testP2(x: S5_P2, p2: P2) {
   p2.f() // expected-error{{call to main actor-isolated instance method 'f()' in a synchronous nonisolated context}}
   p2.g() // OKAY

test/Concurrency/actor_keypath_isolation.swift

@@ -1,7 +1,7 @@
 // RUN: %target-typecheck-verify-swift  -disable-availability-checking -warn-concurrency
 // REQUIRES: concurrency
 
-class Box {
+class Box { // expected-note 3{{class 'Box' does not conform to the `Sendable` protocol}}
     let size : Int = 0
 }
 

test/Concurrency/concurrent_value_checking.swift

@@ -1,7 +1,7 @@
 // RUN: %target-typecheck-verify-swift  -disable-availability-checking -warn-concurrency
 // REQUIRES: concurrency
 
-class NotConcurrent { }
+class NotConcurrent { } // expected-note 17{{class 'NotConcurrent' does not conform to the `Sendable` protocol}}
 
 // ----------------------------------------------------------------------
 // Sendable restriction on actor operations
@@ -77,7 +77,7 @@ struct HasSubscript {
   subscript (i: Int) -> NotConcurrent? { nil }
 }
 
-class ClassWithGlobalActorInits {
+class ClassWithGlobalActorInits { // expected-note 2{{class 'ClassWithGlobalActorInits' does not conform to the `Sendable` protocol}}
   @SomeGlobalActor
   init(_: NotConcurrent) { }
 
@@ -144,7 +144,7 @@ func testUnsafeSendableInAsync() async {
 // ----------------------------------------------------------------------
 // Sendable restriction on key paths.
 // ----------------------------------------------------------------------
-class NC: Hashable {
+class NC: Hashable { // expected-note 3{{class 'NC' does not conform to the `Sendable` protocol}}
   func hash(into: inout Hasher) { }
   static func==(_: NC, _: NC) -> Bool { true }
 }

test/Concurrency/concurrent_value_checking_objc.swift

@@ -13,7 +13,7 @@ final class B: NSObject, Sendable {
   var x: Int = 5 // expected-error{{stored property 'x' of 'Sendable'-conforming class 'B' is mutable}}
 }
 
-class C { }
+class C { } // expected-note{{class 'C' does not conform to the `Sendable` protocol}}
 
 final class D: NSObject, Sendable {
   let c: C = C() // expected-error{{stored property 'c' of 'Sendable'-conforming class 'D' has non-sendable type 'C'}}