[Concurrency] Diagnose redundant nonisolated(unsafe) for a Sendable immutable storage.

Author: simanerush

include/swift/AST/DiagnosticsSema.def

@@ -5686,6 +5686,10 @@ NOTE(nonisolated_mutable_storage_note,none,
      "convert %0 to a 'let' constant or consider declaring it "
      "'nonisolated(unsafe)' if manually managing concurrency safety",
      (const VarDecl *))
+WARNING(nonisolated_unsafe_sendable_constant,none,
+     "'nonisolated(unsafe)' is unnecessary for a constant with 'Sendable' type "
+     "%0, consider removing it",
+     (Type))
 ERROR(nonisolated_non_sendable,none,
       "'nonisolated' can not be applied to variable with non-'Sendable' "
       "type %0",

lib/Sema/TypeCheckAttr.cpp

@@ -6921,6 +6921,15 @@ void AttributeChecker::visitNonisolatedAttr(NonisolatedAttr *attr) {
           return;
         }
       }
+
+      // 'nonisolated(unsafe)' is redundant for 'Sendable' immutables.
+      if (attr->isUnsafe() &&
+          type->isSendableType() &&
+          var->isLet()) {
+        diagnose(attr->getLocation(),
+                 diag::nonisolated_unsafe_sendable_constant, type)
+            .fixItRemove(attr->getRange());
+      }
     }
 
     // Using 'nonisolated' with wrapped properties is unsupported, because

test/Concurrency/global_variables.swift

@@ -41,6 +41,8 @@ struct TestStatics {
   static let immutableExplicitSendable = TestSendable()
   static let immutableNonsendable = TestNonsendable() // expected-error{{static property 'immutableNonsendable' is not concurrency-safe because it is not either conforming to 'Sendable' or isolated to a global actor}}
   static nonisolated(unsafe) let immutableNonisolatedUnsafe = TestNonsendable()
+  static nonisolated(unsafe) let immutableNonisolatedUnsafeSendable = TestSendable()
+  // expected-warning@-1 {{'nonisolated(unsafe)' is unnecessary for a constant with 'Sendable' type 'TestSendable', consider removing it}} {{10-30=}}
   static nonisolated let immutableNonisolated = TestNonsendable() // expected-error{{static property 'immutableNonisolated' is not concurrency-safe because it is not either conforming to 'Sendable' or isolated to a global actor}}
   // expected-error@-1 {{'nonisolated' can not be applied to variable with non-'Sendable' type 'TestNonsendable'}}
   static let immutableInferredSendable = 0
@@ -61,6 +63,9 @@ func f() {
 }
 
 func testLocalNonisolatedUnsafe() async {
+  nonisolated(unsafe) let immutable = 1
+  // expected-warning@-1{{'nonisolated(unsafe)' is unnecessary for a constant with 'Sendable' type 'Int', consider removing it}} {{3-23=}}
+  // expected-warning@-2{{initialization of immutable value 'immutable' was never used; consider replacing with assignment to '_' or removing it}}
   nonisolated(unsafe) var value = 1
   let task = Task {
     value = 2