Don't diagnose uses of @unchecked Sendable conformances

The `@unchecked` conformance is effectively the same as
`@safe(unchecked)`, in that it asserts memory safety in a place where
it cannot be automatically checked. But once that has been asserted,
there is no reason to diagnose anywhere else.

While here, drop the "unsafe declaration here" note, which isn't
adding value but did add noise.

Thanks, Alex!

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -8086,9 +8086,9 @@ NOTE(note_reference_to_nonisolated_unsafe,none,
      (const ValueDecl *))
 NOTE(note_reference_unowned_unsafe,none,
      "reference to unowned(unsafe) %kind0 is unsafe", (const ValueDecl *))
-NOTE(note_use_of_unchecked_conformance_is_unsafe,none,
-     "%select{@unchecked|@unsafe}0 conformance of %1 to %kind2 involves unsafe code",
-     (bool, Type, const ValueDecl *))
+NOTE(note_use_of_unsafe_conformance_is_unsafe,none,
+     "@unsafe conformance of %0 to %kind1 involves unsafe code",
+     (Type, const ValueDecl *))
 GROUPED_WARNING(conformance_involves_unsafe,Unsafe,none,
      "conformance of %0 to %kind1 involves unsafe code; use '@unsafe' to "
      "indicate that the conformance is not memory-safe",
@@ -8102,9 +8102,9 @@ NOTE(note_type_witness_unsafe,none,
 
 GROUPED_WARNING(override_safe_withunsafe,Unsafe,none,
       "override of safe %0 with unsafe %0", (DescriptiveDeclKind))
-GROUPED_WARNING(use_of_unchecked_conformance_is_unsafe,Unsafe,none,
-      "%select{@unchecked|@unsafe}0 conformance of %1 to %kind2 involves unsafe code",
-       (bool, Type, const ValueDecl *))
+GROUPED_WARNING(use_of_unsafe_conformance_is_unsafe,Unsafe,none,
+      "@unsafe conformance of %0 to %kind1 involves unsafe code",
+       (Type, const ValueDecl *))
 GROUPED_WARNING(reference_unowned_unsafe,Unsafe,none,
       "reference to unowned(unsafe) %kind0 is unsafe", (const ValueDecl *))
 GROUPED_WARNING(reference_to_nonisolated_unsafe,Unsafe,none,
@@ -8120,8 +8120,6 @@ GROUPED_WARNING(preconcurrency_import_unsafe,Unsafe,none,
       "@preconcurrency import is not memory-safe because it can silently "
       "introduce data races; use '@safe(unchecked)' to assert that the "
       "code is memory-safe", ())
-NOTE(unsafe_decl_here,none,
-     "unsafe %kindbase0 declared here", (const ValueDecl *))
 NOTE(encapsulate_unsafe_in_enclosing_context,none,
      "make %kindbase0 @safe(unchecked) to allow it to use unsafe constructs in its definition",
      (const Decl *))

lib/Sema/TypeCheckAvailability.cpp

@@ -4772,18 +4772,6 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
   if (!where.getAvailability().allowsUnsafe() &&
       ctx.LangOpts.hasFeature(Feature::WarnUnsafe)) {
     if (auto normalConf = dyn_cast<NormalProtocolConformance>(rootConf)) {
-      // @unchecked Sendable conformances are considered unsafe when complete
-      // checking is enabled.
-      if (normalConf->isUnchecked() &&
-          normalConf->getProtocol()->isSpecificProtocol(KnownProtocolKind::Sendable) &&
-          normalConf->getProtocol()->getASTContext()
-            .LangOpts.StrictConcurrencyLevel == StrictConcurrency::Complete) {
-        diagnoseUnsafeUse(
-            UnsafeUse::forConformance(
-              concreteConf->getType(), conformance, loc,
-              where.getDeclContext()));
-      }
-
       // @unsafe conformances are considered... unsafe.
       if (normalConf->isUnsafe()) {
         diagnoseUnsafeUse(

lib/Sema/TypeCheckType.cpp

@@ -6699,12 +6699,6 @@ void swift::diagnoseUnsafeType(ASTContext &ctx, SourceLoc loc, Type type,
   });
 
   diagnose(specificType ? specificType : type);
-
-  if (specificType) {
-    if (auto specificTypeDecl = specificType->getAnyNominal()) {
-      specificTypeDecl->diagnose(diag::unsafe_decl_here, specificTypeDecl);
-    }
-  }
 }
 
 void swift::diagnoseUnsafeType(ASTContext &ctx, SourceLoc loc, Type type,

lib/Sema/TypeCheckUnsafe.cpp

@@ -150,22 +150,10 @@ void swift::diagnoseUnsafeUse(const UnsafeUse &use, bool asNote) {
   case UnsafeUse::UnsafeConformance: {
     auto conformance = use.getConformance();
     ASTContext &ctx = conformance.getRequirement()->getASTContext();
-
-    // Figure out whether to diagnose @unchecked or @unsafe.
-    bool isUnsafe = true;
-    if (conformance.isConcrete()) {
-      if (auto normal =
-              conformance.getConcrete()->getRootNormalConformance()){
-        if (normal->isUnchecked() && !normal->isUnsafe())
-          isUnsafe = false;
-      }
-    }
-
     ctx.Diags.diagnose(
         use.getLocation(),
-        asNote ? diag::note_use_of_unchecked_conformance_is_unsafe
-               : diag::use_of_unchecked_conformance_is_unsafe,
-        isUnsafe,
+        asNote ? diag::note_use_of_unsafe_conformance_is_unsafe
+               : diag::use_of_unsafe_conformance_is_unsafe,
         use.getType(),
         conformance.getRequirement());
     return;
@@ -231,7 +219,6 @@ void swift::diagnoseUnsafeUse(const UnsafeUse &use, bool asNote) {
 
     if (!asNote) {
       suggestUnsafeOnEnclosingDecl(loc, use.getDeclContext());
-      decl->diagnose(diag::unsafe_decl_here, decl);
     }
 
     return;

test/Unsafe/unsafe.swift

@@ -87,7 +87,7 @@ struct SuperHolder {
 // -----------------------------------------------------------------------
 // Inheritance of @unsafe
 // -----------------------------------------------------------------------
-@unsafe class UnsafeSuper { // expected-note 2{{'UnsafeSuper' declared here}}
+@unsafe class UnsafeSuper {
   func f() { }
 };
 

test/Unsafe/unsafe_concurrency.swift

@@ -32,11 +32,10 @@ func f() async { // expected-warning{{global function 'f' involves unsafe code;
   print(counter) // expected-note{{reference to nonisolated(unsafe) var 'counter' is unsafe in concurrently-executing code}}
   print(globalCounter) // expected-note{{reference to nonisolated(unsafe) var 'globalCounter' is unsafe in concurrently-executing code}}
 
-  acceptSendable(C()) // expected-note{{@unchecked conformance of 'C' to protocol 'Sendable' involves unsafe code}}
+  acceptSendable(C()) // okay
 }
 
-// expected-warning@+1{{type alias 'WeirdC' involves unsafe code; use '@unsafe' to indicate that its use is not memory-safe}}
-typealias WeirdC = RequiresSendable<C> // expected-note{{@unchecked conformance of 'C' to protocol 'Sendable' involves unsafe code}}
+typealias WeirdC = RequiresSendable<C> // okay
 
 
 @available(SwiftStdlib 5.9, *)