AST: Introduce Decl::getNoAsyncAttr().

Author: tshortli

include/swift/AST/Attr.h

@@ -2931,11 +2931,6 @@ class DeclAttributes {
   findMostSpecificActivePlatform(const ASTContext &ctx,
                                  bool ignoreAppExtensions = false) const;
 
-  /// Returns the first @available attribute that indicates
-  /// a declaration is unavailable from asynchronous contexts, or null
-  /// otherwise.
-  const AvailableAttr *getNoAsync(const ASTContext &ctx) const;
-
   /// Returns the `@backDeployed` attribute that is active for the current
   /// platform.
   const BackDeployedAttr *getBackDeployed(const ASTContext &ctx,

include/swift/AST/Decl.h

@@ -1402,6 +1402,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   /// will be deprecated in the future, or `nullptr` otherwise.
   const AvailableAttr *getSoftDeprecatedAttr() const;
 
+  /// Returns the first @available attribute that indicates this decl is
+  /// unavailable from asynchronous contexts, or `nullptr` otherwise.
+  const AvailableAttr *getNoAsyncAttr() const;
+
   /// Returns true if the decl has been marked unavailable in the Swift language
   /// version that is currently active.
   bool isUnavailableInCurrentSwiftVersion() const;

lib/AST/Attr.cpp

@@ -404,48 +404,6 @@ DeclAttributes::findMostSpecificActivePlatform(const ASTContext &ctx,
   return bestAttr;
 }
 
-const AvailableAttr *DeclAttributes::getNoAsync(const ASTContext &ctx) const {
-  const AvailableAttr *bestAttr = nullptr;
-  for (const DeclAttribute *attr : *this) {
-    if (const AvailableAttr *avAttr = dyn_cast<AvailableAttr>(attr)) {
-      if (avAttr->isInvalid())
-        continue;
-
-      if (avAttr->getPlatformAgnosticAvailability() ==
-          PlatformAgnosticAvailabilityKind::NoAsync) {
-        // An API may only be unavailable on specific platforms.
-        // If it doesn't have a platform associated with it, then it's
-        // unavailable for all platforms, so we should include it. If it does
-        // have a platform and we are not that platform, then it doesn't apply
-        // to us.
-        const bool isGoodForPlatform =
-            (avAttr->hasPlatform() && avAttr->isActivePlatform(ctx)) ||
-            !avAttr->hasPlatform();
-
-        if (!isGoodForPlatform)
-          continue;
-
-        if (!bestAttr) {
-          // If there is no best attr selected
-          // and the attr either has an active platform, or doesn't have one at
-          // all, select it.
-          bestAttr = avAttr;
-        } else if (bestAttr && avAttr->hasPlatform() &&
-                   bestAttr->hasPlatform() &&
-                   inheritsAvailabilityFromPlatform(avAttr->getPlatform(),
-                                                    bestAttr->getPlatform())) {
-          // if they both have a viable platform, use the better one
-          bestAttr = avAttr;
-        } else if (avAttr->hasPlatform() && !bestAttr->hasPlatform()) {
-          // Use the one more specific
-          bestAttr = avAttr;
-        }
-      }
-    }
-  }
-  return bestAttr;
-}
-
 const BackDeployedAttr *
 DeclAttributes::getBackDeployed(const ASTContext &ctx,
                                 bool forTargetVariant) const {

lib/AST/Availability.cpp

@@ -554,6 +554,42 @@ const AvailableAttr *Decl::getSoftDeprecatedAttr() const {
   return result;
 }
 
+const AvailableAttr *Decl::getNoAsyncAttr() const {
+  auto &ctx = getASTContext();
+  const AvailableAttr *bestAttr = nullptr;
+
+  for (auto attr :
+       getAttrs().getAttributes<AvailableAttr, /*AllowInvalid=*/false>()) {
+
+    if (attr->getPlatformAgnosticAvailability() !=
+        PlatformAgnosticAvailabilityKind::NoAsync)
+      continue;
+
+    if (attr->hasPlatform() && !attr->isActivePlatform(ctx))
+      continue;
+
+    if (!bestAttr) {
+      bestAttr = attr;
+      continue;
+    }
+
+    if (!bestAttr) {
+      // If there is no best attr selected  and the attr either has an active
+      // platform, or doesn't have one at all, select it.
+      bestAttr = attr;
+    } else if (bestAttr && attr->hasPlatform() && bestAttr->hasPlatform() &&
+               inheritsAvailabilityFromPlatform(attr->getPlatform(),
+                                                bestAttr->getPlatform())) {
+      // if they both have a viable platform, use the better one
+      bestAttr = attr;
+    } else if (attr->hasPlatform() && !bestAttr->hasPlatform()) {
+      // Use the one more specific
+      bestAttr = attr;
+    }
+  }
+  return bestAttr;
+}
+
 bool Decl::isUnavailableInCurrentSwiftVersion() const {
   llvm::VersionTuple vers = getASTContext().LangOpts.EffectiveLanguageVersion;
   for (auto attr :

lib/Sema/TypeCheckAvailability.cpp

@@ -4110,7 +4110,7 @@ diagnoseDeclAsyncAvailability(const ValueDecl *D, SourceRange R,
   }
 
   // @available(noasync) spelling
-  if (const AvailableAttr *attr = D->getAttrs().getNoAsync(ctx)) {
+  if (const AvailableAttr *attr = D->getNoAsyncAttr()) {
     SourceLoc diagLoc = call ? call->getLoc() : R.Start;
     auto diag = ctx.Diags.diagnose(diagLoc, diag::async_unavailable_decl,
                                    D, attr->Message);