[Sema]: improve noasync diagnostics in defer statement bodies

updates noasync diagnostics in TypeCheckAvailability.cpp to diagnose
defer bodies as if they had the same `isAsyncContext()` value as their
nearest non-defer parent scope.

resolves: #73614

Author: jamieQ

lib/Sema/TypeCheckAvailability.cpp

@@ -397,6 +397,27 @@ static bool shouldAllowReferenceToUnavailableInSwiftDeclaration(
   return false;
 }
 
+// Utility function to help determine if noasync diagnostics are still
+// appropriate even if a `DeclContext` returns `false` from `isAsyncContext()`.
+static bool
+shouldTreatDeclContextAsAsyncForDiagnostics(const DeclContext *DC) {
+  switch (DC->getContextKind()) {
+    case DeclContextKind::AbstractFunctionDecl: {
+      auto *FD = dyn_cast<FuncDecl>(DC->getAsDecl());
+      if (FD && FD->isDeferBody()) {
+        // If this is a defer body, we should delegate the determination
+        // to its parent.
+        return shouldTreatDeclContextAsAsyncForDiagnostics(DC->getParent());
+      } else {
+        return DC->isAsyncContext();
+      }
+    }
+
+    default:
+      return DC->isAsyncContext();
+  }
+}
+
 namespace {
 
 /// A class to walk the AST to build the type refinement context hierarchy.
@@ -3781,17 +3802,20 @@ bool ExprAvailabilityWalker::diagnoseDeclRefAvailability(
 static bool
 diagnoseDeclAsyncAvailability(const ValueDecl *D, SourceRange R,
                               const Expr *call, const ExportContext &Where) {
-  // If we are in a synchronous context, don't check it
-  if (!Where.getDeclContext()->isAsyncContext())
+  // If we are not in an (effective) async context, don't check it
+  if (!shouldTreatDeclContextAsAsyncForDiagnostics(Where.getDeclContext()))
     return false;
 
   ASTContext &ctx = Where.getDeclContext()->getASTContext();
 
-  if (const AbstractFunctionDecl *afd = dyn_cast<AbstractFunctionDecl>(D)) {
-    if (const AbstractFunctionDecl *asyncAlt = afd->getAsyncAlternative()) {
-      SourceLoc diagLoc = call ? call->getLoc() : R.Start;
-      ctx.Diags.diagnose(diagLoc, diag::warn_use_async_alternative);
-      asyncAlt->diagnose(diag::decl_declared_here, asyncAlt);
+  // Only suggest async alternatives if the DeclContext is truly async
+  if (Where.getDeclContext()->isAsyncContext()) {
+    if (const AbstractFunctionDecl *afd = dyn_cast<AbstractFunctionDecl>(D)) {
+      if (const AbstractFunctionDecl *asyncAlt = afd->getAsyncAlternative()) {
+        SourceLoc diagLoc = call ? call->getLoc() : R.Start;
+        ctx.Diags.diagnose(diagLoc, diag::warn_use_async_alternative);
+        asyncAlt->diagnose(diag::decl_declared_here, asyncAlt);
+      }
     }
   }
 

test/attr/attr_availability_async_rename_toplevel.swift

@@ -5,7 +5,7 @@
 if #available(SwiftStdlib 5.5, *) {
   @available(*, renamed: "process(data:)")
   func process(data: [Int], completion: @escaping ([Int]) -> Void) { completion(data) }
-  // expected-note@+1{{'process(data:)' declared here}}
+  // expected-note@+1 {{'process(data:)' declared here}}
   func process(data: [Int]) async -> [Int] { return data }
 
   func asyncFunc(data: [Int]) async {

test/attr/attr_availability_noasync.swift

@@ -27,6 +27,15 @@ actor IOActor {
 
 @available(SwiftStdlib 5.5, *)
 func asyncFunc() async {
+    defer {
+        defer {
+            // expected-warning@+1 {{global function 'basicNoAsync' is unavailable from asynchronous contexts; this is an error in the Swift 6 language mode}}
+            basicNoAsync()
+        }
+        // expected-warning@+1 {{global function 'basicNoAsync' is unavailable from asynchronous contexts; this is an error in the Swift 6 language mode}}
+        basicNoAsync()
+    }
+
     // expected-warning@+1{{global function 'basicNoAsync' is unavailable from asynchronous contexts; this is an error in the Swift 6 language mode}}
     basicNoAsync()