AST: Introduce SemanticAvailableAttr::getIntroducedRange().

It replaces the overload of AvailabilityInference::availableRange() that takes
an AvailableAttr.

Author: tshortli

include/swift/AST/Attr.h

@@ -21,6 +21,7 @@
 #include "swift/AST/AttrKind.h"
 #include "swift/AST/AutoDiff.h"
 #include "swift/AST/AvailabilityDomain.h"
+#include "swift/AST/AvailabilityRange.h"
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/DeclNameLoc.h"
 #include "swift/AST/Identifier.h"
@@ -3231,14 +3232,21 @@ class SemanticAvailableAttr final {
   const AvailableAttr *getParsedAttr() const { return attr; }
   const AvailabilityDomain getDomain() const { return domain; }
 
+  /// The version tuple written in source for the `introduced:` component.
   std::optional<llvm::VersionTuple> getIntroduced() const {
     return attr->Introduced;
   }
 
+  /// Returns the effective range in which the declaration with this attribute
+  /// was introduced.
+  AvailabilityRange getIntroducedRange(ASTContext &Ctx) const;
+
+  /// The version tuple written in source for the `deprecated:` component.
   std::optional<llvm::VersionTuple> getDeprecated() const {
     return attr->Deprecated;
   }
 
+  /// The version tuple written in source for the `obsoleted:` component.
   std::optional<llvm::VersionTuple> getObsoleted() const {
     return attr->Obsoleted;
   }

include/swift/AST/AvailabilityInference.h

@@ -55,13 +55,6 @@ class AvailabilityInference {
   /// Returns true is the declaration is `@_spi_available`.
   static bool isAvailableAsSPI(const Decl *D);
 
-  /// Returns the range of platform versions in which a declaration with the
-  /// given `@available` attribute is available.
-  ///
-  /// NOTE: The attribute must be active on the current platform.
-  static AvailabilityRange availableRange(const AvailableAttr *attr,
-                                          ASTContext &C);
-
   /// Returns the context for which the declaration
   /// is annotated as available, or None if the declaration
   /// has no availability annotation.

lib/AST/Availability.cpp

@@ -80,7 +80,7 @@ AvailabilityConstraint::getRequiredNewerAvailabilityRange(
   case Kind::Obsoleted:
     return std::nullopt;
   case Kind::IntroducedInNewerVersion:
-    return AvailabilityInference::availableRange(attr.getParsedAttr(), ctx);
+    return attr.getIntroducedRange(ctx);
   }
 }
 
@@ -453,7 +453,7 @@ AvailabilityInference::annotatedAvailableRange(const Decl *D) {
   if (!bestAvailAttr)
     return std::nullopt;
 
-  return availableRange(bestAvailAttr->getParsedAttr(), D->getASTContext());
+  return bestAvailAttr->getIntroducedRange(D->getASTContext());
 }
 
 bool Decl::isAvailableAsSPI() const {
@@ -785,7 +785,7 @@ AvailabilityRange AvailabilityInference::annotatedAvailableRangeForAttr(
   }
 
   if (bestAvailAttr)
-    return availableRange(bestAvailAttr->getParsedAttr(), ctx);
+    return bestAvailAttr->getIntroducedRange(ctx);
 
   return AvailabilityRange::alwaysAvailable();
 }
@@ -814,10 +814,9 @@ attrForAvailableRange(const Decl *D) {
 
 std::pair<AvailabilityRange, const AvailableAttr *>
 AvailabilityInference::availableRangeAndAttr(const Decl *D) {
-  if (auto rangeAttr = attrForAvailableRange(D)) {
-    auto attr = rangeAttr->getParsedAttr();
-    return {availableRange(attr, D->getASTContext()), attr};
-  }
+  if (auto rangeAttr = attrForAvailableRange(D))
+    return {rangeAttr->getIntroducedRange(D->getASTContext()),
+            rangeAttr->getParsedAttr()};
 
   // Treat unannotated declarations as always available.
   return {AvailabilityRange::alwaysAvailable(), nullptr};
@@ -835,8 +834,8 @@ bool AvailabilityInference::isAvailableAsSPI(const Decl *D) {
 }
 
 AvailabilityRange
-AvailabilityInference::availableRange(const AvailableAttr *attr,
-                                      ASTContext &Ctx) {
+SemanticAvailableAttr::getIntroducedRange(ASTContext &Ctx) const {
+  auto *attr = getParsedAttr();
   assert(attr->isActivePlatform(Ctx));
 
   llvm::VersionTuple IntroducedVersion = attr->Introduced.value();

lib/AST/AvailabilityScope.cpp

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

lib/Sema/TypeCheckAttr.cpp

@@ -2378,16 +2378,17 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
   // is fully contained within that declaration's range. If there is no such
   // enclosing declaration, then there is nothing to check.
   std::optional<AvailabilityRange> EnclosingAnnotatedRange;
-  AvailabilityRange AttrRange =
-      AvailabilityInference::availableRange(attr, Ctx);
+  AvailabilityRange AttrRange = semanticAttr->getIntroducedRange(Ctx);
 
   if (auto *parent = getEnclosingDeclForDecl(D)) {
     if (auto enclosingAvailable =
             getSemanticAvailableRangeDeclAndAttr(parent)) {
-      const AvailableAttr *enclosingAttr = enclosingAvailable.value().first;
       const Decl *enclosingDecl = enclosingAvailable.value().second;
-      EnclosingAnnotatedRange.emplace(
-          AvailabilityInference::availableRange(enclosingAttr, Ctx));
+      SemanticAvailableAttr enclosingAttr =
+          enclosingDecl
+              ->getSemanticAvailableAttr(enclosingAvailable.value().first)
+              .value();
+      EnclosingAnnotatedRange.emplace(enclosingAttr.getIntroducedRange(Ctx));
       if (!AttrRange.isContainedIn(*EnclosingAnnotatedRange)) {
         auto limit = DiagnosticBehavior::Unspecified;
         if (D->isImplicit()) {