Expand the collation of unsafe constructs to all declarations that can handle it

Drive the strict-safety diagnostics for a particular declaration from
primary type checking for declarations, so any memory-safety-related
diagnostics will only be emitted for the primary files. This also
brings them together as notes under a single warning for each
declaration.

Author: DougGregor

lib/Sema/TypeCheckAvailability.h

@@ -280,7 +280,6 @@ void diagnoseUnsafeUse(const UnsafeUse &use, bool asNote = false);
 /// declaration, if there are any.
 void diagnoseUnsafeUsesIn(const Decl *decl);
 
-
 } // namespace swift
 
 #endif // SWIFT_SEMA_TYPE_CHECK_AVAILABILITY_H

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2348,8 +2348,21 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
             { });
       }
     }
+
+    // Diagnose any uses of unsafe constructs within this declaration.
+    if (!hasUnsafeCheckingOutsideOfPrimary(decl))
+      diagnoseUnsafeUsesIn(decl);
   }
 
+  /// Determine whether @unsafe checking for this declaration occurs outside
+  /// of "primary" declaration checking, e.g., with the request that
+  /// type-checks a function body.
+  static bool hasUnsafeCheckingOutsideOfPrimary(const Decl *decl) {
+    if (auto func = dyn_cast<AbstractFunctionDecl>(decl))
+      return func->hasBody();
+
+    return false;
+  }
 
   //===--------------------------------------------------------------------===//
   // Visit Methods.

lib/Sema/TypeCheckUnsafe.cpp

@@ -87,16 +87,6 @@ static void suggestUnsafeMarkerOnConformance(
   ).fixItInsert(decl->getAttributeInsertionLoc(false), "@unsafe ");
 }
 
-static bool shouldDeferUnsafeUseIn(const Decl *decl) {
-  if (auto func = dyn_cast_or_null<AbstractFunctionDecl>(decl)) {
-    if (func->hasBody()) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
 /// Retrieve the extra information
 static SourceFileExtras &getSourceFileExtrasFor(const Decl *decl) {
   auto dc = decl->getDeclContext();
@@ -112,7 +102,7 @@ void swift::diagnoseUnsafeUse(const UnsafeUse &use, bool asNote) {
         use.getKind() == UnsafeUse::CallToUnsafe) {
       auto [enclosingDecl, _] = enclosingContextForUnsafe(
           use.getLocation(), use.getDeclContext());
-      if (enclosingDecl && shouldDeferUnsafeUseIn(enclosingDecl)) {
+      if (enclosingDecl) {
         getSourceFileExtrasFor(enclosingDecl).unsafeUses[enclosingDecl]
           .push_back(use);
         return;

test/Unsafe/unsafe-suppression.swift

@@ -91,7 +91,7 @@ class NonSendable { }
 
 
 @unsafe
-struct UnsafeOuter { // expected-note{{unsafe struct 'UnsafeOuter' declared here}}
+struct UnsafeOuter {
   func f(_: UnsafeType) { } // okay
 
   @unsafe func g(_ y: UnsafeType) {
@@ -100,8 +100,8 @@ struct UnsafeOuter { // expected-note{{unsafe struct 'UnsafeOuter' declared here
   }
 }
 
-// expected-note@+1{{make extension of struct 'UnsafeOuter' @unsafe to indicate that its use is not memory-safe}}{{1-1=@unsafe }}
-extension UnsafeOuter { // expected-warning{{reference to unsafe struct 'UnsafeOuter' [Unsafe]}}
+// expected-warning@+1{{extension of struct 'UnsafeOuter' involves unsafe code; use '@unsafe' to indicate that its use is not memory-safe}}{{1-1=@unsafe }}
+extension UnsafeOuter { // expected-note{{reference to unsafe struct 'UnsafeOuter'}}
   func h(_: UnsafeType) { }
 }
 

test/Unsafe/unsafe.swift

@@ -61,12 +61,12 @@ struct SuperHolder {
 // -----------------------------------------------------------------------
 // Inheritance of @unsafe
 // -----------------------------------------------------------------------
-@unsafe class UnsafeSuper { // expected-note 4{{'UnsafeSuper' declared here}}
+@unsafe class UnsafeSuper { // expected-note{{'UnsafeSuper' declared here}}
   func f() { }
 };
 
-class UnsafeSub: UnsafeSuper { } // expected-warning{{reference to unsafe class 'UnsafeSuper'}}
-// expected-note@-1{{make class 'UnsafeSub' @unsafe to indicate that its use is not memory-safe}}{{1-1=@unsafe }}
+class UnsafeSub: UnsafeSuper { } // expected-warning{{class 'UnsafeSub' involves unsafe code; use '@unsafe' to indicate that its use is not memory-safe}}{{1-1=@unsafe }}
+// expected-note@-1{{reference to unsafe class 'UnsafeSuper'}}
 
 // -----------------------------------------------------------------------
 // Declaration references
@@ -90,13 +90,13 @@ func testMe(
 // -----------------------------------------------------------------------
 // Various declaration kinds
 // -----------------------------------------------------------------------
-// expected-note@+1{{make type alias 'SuperUnsafe' @unsafe to indicate that its use is not memory-safe}}{{1-1=@unsafe }}
-typealias SuperUnsafe = UnsafeSuper // expected-warning{{reference to unsafe class 'UnsafeSuper' [Unsafe]}}
+// expected-warning@+1{{type alias 'SuperUnsafe' involves unsafe code; use '@unsafe' to indicate that its use is not memory-safe}}{{1-1=@unsafe }}
+typealias SuperUnsafe = UnsafeSuper // expected-note{{reference to unsafe class 'UnsafeSuper'}}
 @unsafe typealias SuperUnsafe2 = UnsafeSuper
 
 enum HasUnsafeThings {
-// expected-note@+1{{make enum case 'one' @unsafe to indicate that its use is not memory-safe}}
-case one(UnsafeSuper) // expected-warning{{reference to unsafe class 'UnsafeSuper' [Unsafe]}}
+// expected-warning@+1{{enum case 'one' involves unsafe code; use '@unsafe' to indicate that its use is not memory-safe}}{{1-1=@unsafe }}
+case one(UnsafeSuper) // expected-note{{reference to unsafe class 'UnsafeSuper'}}
 
 @unsafe case two(UnsafeSuper)
 }