AST: Introduce Decl::getAvailableAttrForPlatformIntroduction().

It replaces `AvailabilityInference::attrForAnnotatedAvailableRange()`.

Author: tshortli

include/swift/AST/AvailabilityInference.h

@@ -62,10 +62,6 @@ class AvailabilityInference {
   static AvailabilityRange availableRange(const AvailableAttr *attr,
                                           ASTContext &C);
 
-  /// Returns the attribute that should be used to determine the availability
-  /// range of the given declaration, or nullptr if there is none.
-  static const AvailableAttr *attrForAnnotatedAvailableRange(const Decl *D);
-
   /// Returns the context for which the declaration
   /// is annotated as available, or None if the declaration
   /// has no availability annotation.

include/swift/AST/Decl.h

@@ -1430,6 +1430,11 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   std::optional<SemanticAvailableAttr> getActiveAvailableAttrForCurrentPlatform(
       bool ignoreAppExtensions = false) const;
 
+  /// Returns the active platform-specific `@available` attribute that should be
+  /// used to determine the platform introduction version of the decl.
+  std::optional<SemanticAvailableAttr>
+  getAvailableAttrForPlatformIntroduction() const;
+
   /// Returns true if the declaration is deprecated at the current deployment
   /// target.
   bool isDeprecated() const { return getDeprecatedAttr().has_value(); }

lib/AST/Availability.cpp

@@ -430,11 +430,11 @@ bool AvailabilityInference::updateBeforePlatformForFallback(
   return false;
 }
 
-const AvailableAttr *
-AvailabilityInference::attrForAnnotatedAvailableRange(const Decl *D) {
+std::optional<SemanticAvailableAttr>
+Decl::getAvailableAttrForPlatformIntroduction() const {
   std::optional<SemanticAvailableAttr> bestAvailAttr;
 
-  D = abstractSyntaxDeclForAvailableAttribute(D);
+  auto D = abstractSyntaxDeclForAvailableAttribute(this);
 
   for (auto attr : D->getSemanticAvailableAttrs(/*includingInactive=*/false)) {
     if (!attr.isPlatformSpecific() || !attr.getIntroduced())
@@ -444,16 +444,16 @@ AvailabilityInference::attrForAnnotatedAvailableRange(const Decl *D) {
       bestAvailAttr.emplace(attr);
   }
 
-  return bestAvailAttr ? bestAvailAttr->getParsedAttr() : nullptr;
+  return bestAvailAttr;
 }
 
 std::optional<AvailabilityRange>
 AvailabilityInference::annotatedAvailableRange(const Decl *D) {
-  auto bestAvailAttr = attrForAnnotatedAvailableRange(D);
+  auto bestAvailAttr = D->getAvailableAttrForPlatformIntroduction();
   if (!bestAvailAttr)
     return std::nullopt;
 
-  return availableRange(bestAvailAttr, D->getASTContext());
+  return availableRange(bestAvailAttr->getParsedAttr(), D->getASTContext());
 }
 
 bool Decl::isAvailableAsSPI() const {
@@ -790,8 +790,9 @@ AvailabilityRange AvailabilityInference::annotatedAvailableRangeForAttr(
   return AvailabilityRange::alwaysAvailable();
 }
 
-static const AvailableAttr *attrForAvailableRange(const Decl *D) {
-  if (auto attr = AvailabilityInference::attrForAnnotatedAvailableRange(D))
+static std::optional<SemanticAvailableAttr>
+attrForAvailableRange(const Decl *D) {
+  if (auto attr = D->getAvailableAttrForPlatformIntroduction())
     return attr;
 
   // Unlike other declarations, extensions can be used without referring to them
@@ -804,16 +805,17 @@ static const AvailableAttr *attrForAvailableRange(const Decl *D) {
 
   DeclContext *DC = D->getDeclContext();
   if (auto *ED = dyn_cast<ExtensionDecl>(DC)) {
-    if (auto attr = AvailabilityInference::attrForAnnotatedAvailableRange(ED))
+    if (auto attr = ED->getAvailableAttrForPlatformIntroduction())
       return attr;
   }
 
-  return nullptr;
+  return std::nullopt;
 }
 
 std::pair<AvailabilityRange, const AvailableAttr *>
 AvailabilityInference::availableRangeAndAttr(const Decl *D) {
-  if (auto attr = attrForAvailableRange(D)) {
+  if (auto rangeAttr = attrForAvailableRange(D)) {
+    auto attr = rangeAttr->getParsedAttr();
     return {availableRange(attr, D->getASTContext()), attr};
   }
 
@@ -827,7 +829,7 @@ AvailabilityRange AvailabilityInference::availableRange(const Decl *D) {
 
 bool AvailabilityInference::isAvailableAsSPI(const Decl *D) {
   if (auto attr = attrForAvailableRange(D))
-    return attr->isSPI();
+    return attr->getParsedAttr()->isSPI();
 
   return false;
 }

lib/AST/AvailabilityScope.cpp

@@ -356,8 +356,9 @@ AvailabilityScope::getExplicitAvailabilityRange() const {
 
   case Reason::Decl: {
     auto decl = Node.getAsDecl();
-    if (auto attr = AvailabilityInference::attrForAnnotatedAvailableRange(decl))
-      return AvailabilityInference::availableRange(attr, decl->getASTContext());
+    if (auto attr = decl->getAvailableAttrForPlatformIntroduction())
+      return AvailabilityInference::availableRange(attr->getParsedAttr(),
+                                                   decl->getASTContext());
 
     return std::nullopt;
   }

lib/Sema/TypeCheckAttr.cpp

@@ -2266,8 +2266,8 @@ static Decl *getEnclosingDeclForDecl(Decl *D) {
 
 static std::optional<std::pair<const AvailableAttr *, const Decl *>>
 getSemanticAvailableRangeDeclAndAttr(const Decl *decl) {
-  if (auto attr = AvailabilityInference::attrForAnnotatedAvailableRange(decl))
-    return std::make_pair(attr, decl);
+  if (auto attr = decl->getAvailableAttrForPlatformIntroduction())
+    return std::make_pair(attr->getParsedAttr(), decl);
 
   if (auto *parent =
           AvailabilityInference::parentDeclForInferredAvailability(decl))