Migrate "@unchecked Sendable" strict safety diagnostic to become a note associated with its type

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -8093,6 +8093,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,
+     "@unchecked conformance of %0 to %kind1 involves unsafe code",
+     (Type, const ValueDecl *))
 
 GROUPED_WARNING(override_safe_withunsafe,Unsafe,none,
       "override of safe %0 with unsafe %0", (DescriptiveDeclKind))
@@ -8102,8 +8105,9 @@ GROUPED_WARNING(witness_unsafe,Unsafe,none,
 GROUPED_WARNING(type_witness_unsafe,Unsafe,none,
       "unsafe type %0 cannot satisfy safe associated type %1",
       (Type, DeclName))
-GROUPED_WARNING(unchecked_conformance_is_unsafe,Unsafe,none,
-      "@unchecked conformance involves unsafe code", ())
+GROUPED_WARNING(use_of_unchecked_conformance_is_unsafe,Unsafe,none,
+      "@unchecked 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,

include/swift/AST/UnsafeUse.h

@@ -15,14 +15,13 @@
 
 #include "swift/AST/Decl.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/Type.h"
 #include "swift/Basic/SourceLoc.h"
 #include "swift/Basic/Unreachable.h"
 
 namespace swift {
 
-class NormalProtocolConformance;
-
 /// Describes a use of an unsafe construct.
 ///
 /// Every use of an unsafe construct that should be diagnosed will be captured
@@ -66,7 +65,8 @@ class UnsafeUse {
     } typeWitness;
 
     struct {
-      NormalProtocolConformance *conformance;
+      TypeBase *type;
+      void *conformanceRef;
       DeclContext *declContext;
       const void *location;
     } conformance;
@@ -139,11 +139,13 @@ class UnsafeUse {
     return result;
   }
 
-  static UnsafeUse forConformance(NormalProtocolConformance *conformance,
+  static UnsafeUse forConformance(Type subjectType,
+                                  ProtocolConformanceRef conformance,
                                   SourceLoc location,
                                   DeclContext *dc) {
     UnsafeUse result(UnsafeConformance);
-    result.storage.conformance.conformance = conformance;
+    result.storage.conformance.type = subjectType.getPointer();
+    result.storage.conformance.conformanceRef = conformance.getOpaqueValue();
     result.storage.conformance.declContext = dc;
     result.storage.conformance.location = location.getOpaquePointerValue();
     return result;
@@ -180,7 +182,9 @@ class UnsafeUse {
       return getDecl()->getLoc();
 
     case UnsafeConformance:
-      return getConformance()->getLoc();
+      return SourceLoc(
+          llvm::SMLoc::getFromPointer(
+            (const char *)storage.conformance.location));
 
     case TypeWitness:
       return SourceLoc(
@@ -237,7 +241,7 @@ class UnsafeUse {
 
     case Witness:
     case TypeWitness:
-      return getConformance()->getDeclContext();
+      return getConformance().getConcrete()->getDeclContext();
 
     case UnsafeConformance:
       return storage.conformance.declContext;
@@ -268,9 +272,11 @@ class UnsafeUse {
     switch (getKind()) {
     case Override:
     case Witness:
-    case UnsafeConformance:
       return nullptr;
 
+    case UnsafeConformance:
+      return storage.conformance.type;
+
     case TypeWitness:
       return storage.typeWitness.type;
 
@@ -283,23 +289,24 @@ class UnsafeUse {
   }
 
   /// Get the protocol conformance, if there is one.
-  NormalProtocolConformance *getConformance() const {
+  ProtocolConformanceRef getConformance() const {
     switch (getKind()) {
     case UnsafeConformance:
-      return storage.conformance.conformance;
+      return ProtocolConformanceRef::getFromOpaqueValue(
+          storage.conformance.conformanceRef);
 
     case Witness:
-      return storage.polymorphic.conformance;
+      return ProtocolConformanceRef(storage.polymorphic.conformance);
 
     case TypeWitness:
-      return storage.typeWitness.conformance;
+      return ProtocolConformanceRef(storage.typeWitness.conformance);
 
     case Override:
     case UnownedUnsafe:
     case NonisolatedUnsafe:
     case ReferenceToUnsafe:
     case CallToUnsafe:
-      return nullptr;
+      return ProtocolConformanceRef::forInvalid();
     }
   }
 };

lib/Sema/TypeCheckProtocol.cpp

@@ -2469,7 +2469,9 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
 
     if (!conformance->getDeclContext()->allowsUnsafe()) {
       diagnoseUnsafeUse(
-          UnsafeUse::forConformance(conformance, ComplainLoc,
+          UnsafeUse::forConformance(conformance->getType(),
+                                    ProtocolConformanceRef(conformance),
+                                    ComplainLoc,
                                     conformance->getDeclContext()));
     }
   }

lib/Sema/TypeCheckUnsafe.cpp

@@ -38,14 +38,14 @@ static bool isUnsafeUseInDefinition(const UnsafeUse &use) {
   case UnsafeUse::Override:
   case UnsafeUse::Witness:
   case UnsafeUse::TypeWitness:
-  case UnsafeUse::UnsafeConformance:
     // Never part of the definition. These are always part of the interface.
     return false;
 
   case UnsafeUse::ReferenceToUnsafe:
   case UnsafeUse::CallToUnsafe:
   case UnsafeUse::NonisolatedUnsafe:
   case UnsafeUse::UnownedUnsafe:
+  case UnsafeUse::UnsafeConformance:
     return enclosingContextForUnsafe(use).second;
   }
 }
@@ -74,7 +74,7 @@ static void suggestUnsafeOnEnclosingDecl(
 }
 
 static void suggestUnsafeMarkerOnConformance(
-    NormalProtocolConformance *conformance) {
+    ProtocolConformance *conformance) {
   auto dc = conformance->getDeclContext();
   auto decl = dc->getAsDecl();
   if (!decl)
@@ -105,7 +105,8 @@ void swift::diagnoseUnsafeUse(const UnsafeUse &use, bool asNote) {
     if (use.getKind() == UnsafeUse::ReferenceToUnsafe ||
         use.getKind() == UnsafeUse::CallToUnsafe ||
         use.getKind() == UnsafeUse::NonisolatedUnsafe ||
-        use.getKind() == UnsafeUse::UnownedUnsafe) {
+        use.getKind() == UnsafeUse::UnownedUnsafe ||
+        use.getKind() == UnsafeUse::UnsafeConformance) {
       auto [enclosingDecl, _] = enclosingContextForUnsafe(
           use.getLocation(), use.getDeclContext());
       if (enclosingDecl) {
@@ -137,15 +138,15 @@ void swift::diagnoseUnsafeUse(const UnsafeUse &use, bool asNote) {
     witness->diagnose(diag::witness_unsafe,
                       witness->getDescriptiveKind(),
                       witness->getName());
-    suggestUnsafeMarkerOnConformance(use.getConformance());
+    suggestUnsafeMarkerOnConformance(use.getConformance().getConcrete());
     return;
   }
 
   case UnsafeUse::TypeWitness: {
     auto assocType = use.getAssociatedType();
     auto loc = use.getLocation();
     auto type = use.getType();
-    auto conformance = use.getConformance();
+    auto conformance = use.getConformance().getConcrete();
     ASTContext &ctx = assocType->getASTContext();
 
     diagnoseUnsafeType(ctx, loc, type, conformance->getDeclContext(),
@@ -161,10 +162,13 @@ void swift::diagnoseUnsafeUse(const UnsafeUse &use, bool asNote) {
 
   case UnsafeUse::UnsafeConformance: {
     auto conformance = use.getConformance();
-    ASTContext &ctx = conformance->getProtocol()->getASTContext();
+    ASTContext &ctx = conformance.getRequirement()->getASTContext();
     ctx.Diags.diagnose(
-        use.getLocation(), diag::unchecked_conformance_is_unsafe);
-    suggestUnsafeMarkerOnConformance(conformance);
+        use.getLocation(),
+        asNote ? diag::note_use_of_unchecked_conformance_is_unsafe
+               : diag::use_of_unchecked_conformance_is_unsafe,
+        use.getType(),
+        conformance.getRequirement());
     return;
   }
 

test/Unsafe/unsafe_concurrency.swift

@@ -4,8 +4,8 @@
 // REQUIRES: swift_feature_StrictConcurrency
 // REQUIRES: swift_feature_WarnUnsafe
 
-// expected-warning@+2{{@unchecked conformance involves unsafe code}}
-// expected-note@+1{{make the enclosing class @unsafe to allow unsafe conformance to protocol 'Sendable'}}{{1-1=@unsafe }}
+// expected-note@+2{{@unchecked conformance of 'C' to protocol 'Sendable' involves unsafe code}}
+// expected-warning@+1{{class 'C' involves unsafe code; use '@unsafe' to indicate that its use is not memory-safe}}{{1-1=@unsafe }}
 class C: @unchecked Sendable {
   var counter: Int = 0
 }