Diagnose the use of a typealias that involves unsafe types

As we do when referencing other kinds of declarations, if a
typealias isn't `@unsafe`, but it involves unsafe types,
diagnose the non-safety at the point of reference.
Fixes #78220

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -8085,6 +8085,9 @@ NOTE(note_reference_to_unsafe_decl,none,
 NOTE(note_reference_to_unsafe_typed_decl,none,
      "%select{reference|call}0 to %kind1 involves unsafe type %2",
      (bool, const ValueDecl *, Type))
+NOTE(note_reference_to_unsafe_through_typealias,none,
+     "reference to %kind0 whose underlying type involves unsafe type %1",
+     (const ValueDecl *, Type))
 NOTE(note_reference_to_nonisolated_unsafe,none,
      "reference to nonisolated(unsafe) %kind0 is unsafe in concurrently-executing code",
      (const ValueDecl *))
@@ -8120,6 +8123,9 @@ GROUPED_WARNING(reference_to_unsafe_decl,Unsafe,none,
 GROUPED_WARNING(reference_to_unsafe_typed_decl,Unsafe,none,
       "%select{reference|call}0 to %kindbase1 involves unsafe type %2",
       (bool, const ValueDecl *, Type))
+GROUPED_WARNING(reference_to_unsafe_through_typealias,Unsafe,none,
+     "reference to %kind0 whose underlying type involves unsafe type %1",
+     (const ValueDecl *, Type))
 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 "

include/swift/AST/UnsafeUse.h

@@ -43,6 +43,9 @@ class UnsafeUse {
     NonisolatedUnsafe,
     /// A reference to an unsafe declaration.
     ReferenceToUnsafe,
+    /// A reference to a typealias that is not itself unsafe, but has
+    /// an unsafe underlying type.
+    ReferenceToUnsafeThroughTypealias,
     /// A call to an unsafe declaration.
     CallToUnsafe,
     /// A @preconcurrency import.
@@ -110,6 +113,7 @@ class UnsafeUse {
     assert(kind == UnownedUnsafe ||
            kind == NonisolatedUnsafe ||
            kind == ReferenceToUnsafe ||
+           kind == ReferenceToUnsafeThroughTypealias ||
            kind == CallToUnsafe);
 
     UnsafeUse result(kind);
@@ -177,6 +181,14 @@ class UnsafeUse {
                         decl, type, location);
   }
 
+  static UnsafeUse forReferenceToUnsafeThroughTypealias(const Decl *decl,
+                                        DeclContext *dc,
+                                        Type type,
+                                        SourceLoc location) {
+    return forReference(ReferenceToUnsafeThroughTypealias, dc,
+                        decl, type, location);
+  }
+
   static UnsafeUse forPreconcurrencyImport(const ImportDecl *importDecl) {
     UnsafeUse result(PreconcurrencyImport);
     result.storage.importDecl = importDecl;
@@ -205,6 +217,7 @@ class UnsafeUse {
     case UnownedUnsafe:
     case NonisolatedUnsafe:
     case ReferenceToUnsafe:
+    case ReferenceToUnsafeThroughTypealias:
     case CallToUnsafe:
       return SourceLoc(
           llvm::SMLoc::getFromPointer((const char *)storage.entity.location));
@@ -227,6 +240,7 @@ class UnsafeUse {
     case UnownedUnsafe:
     case NonisolatedUnsafe:
     case ReferenceToUnsafe:
+    case ReferenceToUnsafeThroughTypealias:
     case CallToUnsafe:
       return storage.entity.decl;
 
@@ -250,6 +264,7 @@ class UnsafeUse {
     case UnownedUnsafe:
     case NonisolatedUnsafe:
     case ReferenceToUnsafe:
+    case ReferenceToUnsafeThroughTypealias:
     case CallToUnsafe:
       return storage.entity.declContext;
 
@@ -281,6 +296,7 @@ class UnsafeUse {
     case UnownedUnsafe:
     case NonisolatedUnsafe:
     case ReferenceToUnsafe:
+    case ReferenceToUnsafeThroughTypealias:
     case CallToUnsafe:
     case UnsafeConformance:
     case PreconcurrencyImport:
@@ -305,6 +321,7 @@ class UnsafeUse {
     case UnownedUnsafe:
     case NonisolatedUnsafe:
     case ReferenceToUnsafe:
+    case ReferenceToUnsafeThroughTypealias:
     case CallToUnsafe:
       return storage.entity.type;
     }
@@ -327,6 +344,7 @@ class UnsafeUse {
     case UnownedUnsafe:
     case NonisolatedUnsafe:
     case ReferenceToUnsafe:
+    case ReferenceToUnsafeThroughTypealias:
     case CallToUnsafe:
     case PreconcurrencyImport:
       return ProtocolConformanceRef::forInvalid();

lib/Sema/TypeCheckAvailability.cpp

@@ -4221,6 +4221,19 @@ diagnoseDeclUnsafe(const ValueDecl *D, SourceRange R,
   }
 
   if (auto valueDecl = dyn_cast<ValueDecl>(D)) {
+    // A typealias that is not itself @unsafe but references an unsafe type
+    // is diagnosed separately.
+    if (auto typealias = dyn_cast<TypeAliasDecl>(valueDecl)) {
+      if (Type underlying = typealias->getUnderlyingType()) {
+        if (underlying->isUnsafe()) {
+          diagnoseUnsafeUse(
+              UnsafeUse::forReferenceToUnsafeThroughTypealias(
+                D, Where.getDeclContext(), underlying, diagLoc));
+          return;
+        }
+      }
+    }
+
     // Use of a nonisolated(unsafe) declaration is unsafe, but is only
     // diagnosed as such under strict concurrency.
     if (ctx.LangOpts.StrictConcurrencyLevel == StrictConcurrency::Complete &&

lib/Sema/TypeCheckUnsafe.cpp

@@ -44,6 +44,7 @@ static bool isUnsafeUseInDefinition(const UnsafeUse &use) {
     return false;
 
   case UnsafeUse::ReferenceToUnsafe:
+  case UnsafeUse::ReferenceToUnsafeThroughTypealias:
   case UnsafeUse::CallToUnsafe:
   case UnsafeUse::NonisolatedUnsafe:
   case UnsafeUse::UnownedUnsafe:
@@ -91,6 +92,7 @@ void swift::diagnoseUnsafeUse(const UnsafeUse &use, bool asNote) {
     // It will be diagnosed later, along with all other unsafe uses within this
     // same declaration.
     if (use.getKind() == UnsafeUse::ReferenceToUnsafe ||
+        use.getKind() == UnsafeUse::ReferenceToUnsafeThroughTypealias ||
         use.getKind() == UnsafeUse::CallToUnsafe ||
         use.getKind() == UnsafeUse::NonisolatedUnsafe ||
         use.getKind() == UnsafeUse::UnownedUnsafe ||
@@ -190,6 +192,21 @@ void swift::diagnoseUnsafeUse(const UnsafeUse &use, bool asNote) {
     }
     return;
   }
+  case UnsafeUse::ReferenceToUnsafeThroughTypealias: {
+    auto typealias = cast<TypeAliasDecl>(use.getDecl());
+    ASTContext &ctx = typealias->getASTContext();
+    diagnoseUnsafeType(
+        ctx, use.getLocation(), use.getType(),
+        use.getDeclContext(),
+        [&](Type specificType) {
+          ctx.Diags.diagnose(
+              use.getLocation(),
+              asNote ? diag::note_reference_to_unsafe_through_typealias
+                     : diag::reference_to_unsafe_through_typealias,
+              typealias, specificType);
+        });
+    return;
+  }
 
   case UnsafeUse::ReferenceToUnsafe:
   case UnsafeUse::CallToUnsafe: {

test/Unsafe/Inputs/unsafe_swift_decls.swift

@@ -1,5 +1,7 @@
 @unsafe public struct PointerType { } // expected-note{{'PointerType' declared here}}
 
+public typealias UnsafeTypeAlias = PointerType
+
 public func getPointers() -> [PointerType] { [] }
 
 public struct HasAPointerType {

test/Unsafe/unsafe_imports.swift

@@ -1,9 +1,13 @@
-// RUN: %target-typecheck-verify-swift -enable-experimental-feature AllowUnsafeAttribute -enable-experimental-feature WarnUnsafe -I %S/Inputs
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module-path %t/unsafe_swift_decls.swiftmodule %S/Inputs/unsafe_swift_decls.swift -enable-experimental-feature AllowUnsafeAttribute
+
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature AllowUnsafeAttribute -enable-experimental-feature WarnUnsafe -I %S/Inputs  -I %t
 
 // REQUIRES: swift_feature_AllowUnsafeAttribute
 // REQUIRES: swift_feature_WarnUnsafe
 
 import unsafe_decls
+import unsafe_swift_decls
 
 // expected-warning@+1{{global function 'testUnsafe' involves unsafe code; use '@unsafe' to indicate that its use is not memory-safe}}{{1-1=@unsafe }}
 func testUnsafe(_ ut: UnsafeType) { // expected-note{{reference to unsafe struct 'UnsafeType'}}
@@ -13,3 +17,10 @@ func testUnsafe(_ ut: UnsafeType) { // expected-note{{reference to unsafe struct
   print_ints(&array, CInt(array.count))
   // expected-note@-1{{call to global function 'print_ints' involves unsafe type 'UnsafeMutablePointer<Int32>'}}
 }
+
+// Reference a typealias that isn't itself @unsafe, but refers to an unsafe
+// type.
+
+// expected-warning@+1{{global function 'testUnsafeThroughAlias' involves unsafe code; use '@unsafe' to indicate that its use is not memory-safe}}
+func testUnsafeThroughAlias(_ ut: UnsafeTypeAlias) { // expected-note{{reference to type alias 'UnsafeTypeAlias' whose underlying type involves unsafe type 'PointerType'}}
+}