AST: Remove AvailabilityInference::availableRangeAndAttr()

Author: tshortli

include/swift/AST/AvailabilityInference.h

@@ -46,12 +46,6 @@ class AvailabilityInference {
   /// Returns the range of platform versions in which the decl is available.
   static AvailabilityRange availableRange(const Decl *D);
 
-  /// Returns the range of platform versions in which the decl is available and
-  /// the attribute which determined this range (which may be `nullptr` if the
-  /// declaration is always available.
-  static std::pair<AvailabilityRange, const AvailableAttr *>
-  availableRangeAndAttr(const Decl *D);
-
   /// Returns true is the declaration is `@_spi_available`.
   static bool isAvailableAsSPI(const Decl *D);
 

lib/AST/Availability.cpp

@@ -430,11 +430,11 @@ bool AvailabilityInference::updateBeforePlatformForFallback(
   return false;
 }
 
-std::optional<SemanticAvailableAttr>
-Decl::getAvailableAttrForPlatformIntroduction() const {
+static std::optional<SemanticAvailableAttr>
+getDeclAvailableAttrForPlatformIntroduction(const Decl *D) {
   std::optional<SemanticAvailableAttr> bestAvailAttr;
 
-  auto D = abstractSyntaxDeclForAvailableAttribute(this);
+  D = abstractSyntaxDeclForAvailableAttribute(D);
 
   for (auto attr : D->getSemanticAvailableAttrs(/*includingInactive=*/false)) {
     if (!attr.isPlatformSpecific() || !attr.getIntroduced())
@@ -790,9 +790,9 @@ AvailabilityRange AvailabilityInference::annotatedAvailableRangeForAttr(
   return AvailabilityRange::alwaysAvailable();
 }
 
-static std::optional<SemanticAvailableAttr>
-attrForAvailableRange(const Decl *D) {
-  if (auto attr = D->getAvailableAttrForPlatformIntroduction())
+std::optional<SemanticAvailableAttr>
+Decl::getAvailableAttrForPlatformIntroduction() const {
+  if (auto attr = getDeclAvailableAttrForPlatformIntroduction(this))
     return attr;
 
   // Unlike other declarations, extensions can be used without referring to them
@@ -803,31 +803,24 @@ attrForAvailableRange(const Decl *D) {
   // itself. This check relies on the fact that we cannot have nested
   // extensions.
 
-  DeclContext *DC = D->getDeclContext();
+  DeclContext *DC = getDeclContext();
   if (auto *ED = dyn_cast<ExtensionDecl>(DC)) {
-    if (auto attr = ED->getAvailableAttrForPlatformIntroduction())
+    if (auto attr = getDeclAvailableAttrForPlatformIntroduction(ED))
       return attr;
   }
 
   return std::nullopt;
 }
 
-std::pair<AvailabilityRange, const AvailableAttr *>
-AvailabilityInference::availableRangeAndAttr(const Decl *D) {
-  if (auto rangeAttr = attrForAvailableRange(D))
-    return {rangeAttr->getIntroducedRange(D->getASTContext()),
-            rangeAttr->getParsedAttr()};
-
-  // Treat unannotated declarations as always available.
-  return {AvailabilityRange::alwaysAvailable(), nullptr};
-}
-
 AvailabilityRange AvailabilityInference::availableRange(const Decl *D) {
-  return availableRangeAndAttr(D).first;
+  if (auto attr = D->getAvailableAttrForPlatformIntroduction())
+    return attr->getIntroducedRange(D->getASTContext());
+
+  return AvailabilityRange::alwaysAvailable();
 }
 
 bool AvailabilityInference::isAvailableAsSPI(const Decl *D) {
-  if (auto attr = attrForAvailableRange(D))
+  if (auto attr = D->getAvailableAttrForPlatformIntroduction())
     return attr->getParsedAttr()->isSPI();
 
   return false;

lib/Sema/TypeCheckAttr.cpp

@@ -2264,10 +2264,10 @@ static Decl *getEnclosingDeclForDecl(Decl *D) {
   return D->getDeclContext()->getInnermostDeclarationDeclContext();
 }
 
-static std::optional<std::pair<const AvailableAttr *, const Decl *>>
+static std::optional<std::pair<SemanticAvailableAttr, const Decl *>>
 getSemanticAvailableRangeDeclAndAttr(const Decl *decl) {
   if (auto attr = decl->getAvailableAttrForPlatformIntroduction())
-    return std::make_pair(attr->getParsedAttr(), decl);
+    return std::make_pair(*attr, decl);
 
   if (auto *parent =
           AvailabilityInference::parentDeclForInferredAvailability(decl))
@@ -2383,11 +2383,8 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
   if (auto *parent = getEnclosingDeclForDecl(D)) {
     if (auto enclosingAvailable =
             getSemanticAvailableRangeDeclAndAttr(parent)) {
-      const Decl *enclosingDecl = enclosingAvailable.value().second;
-      SemanticAvailableAttr enclosingAttr =
-          enclosingDecl
-              ->getSemanticAvailableAttr(enclosingAvailable.value().first)
-              .value();
+      SemanticAvailableAttr enclosingAttr = enclosingAvailable->first;
+      const Decl *enclosingDecl = enclosingAvailable->second;
       EnclosingAnnotatedRange.emplace(enclosingAttr.getIntroducedRange(Ctx));
       if (!AttrRange.isContainedIn(*EnclosingAnnotatedRange)) {
         auto limit = DiagnosticBehavior::Unspecified;
@@ -5021,7 +5018,7 @@ void AttributeChecker::checkBackDeployedAttrs(
             getSemanticAvailableRangeDeclAndAttr(VD)) {
       auto beforePlatformString = prettyPlatformString(Attr->Platform);
       auto beforeVersion = Attr->Version;
-      auto availableAttr = availableRangeAttrPair.value().first;
+      auto availableAttr = availableRangeAttrPair.value().first.getParsedAttr();
       auto introVersion = availableAttr->Introduced.value();
       StringRef introPlatformString = availableAttr->prettyPlatformString();
 

lib/Sema/TypeCheckAvailability.cpp

@@ -3182,10 +3182,11 @@ swift::getUnsatisfiedAvailabilityConstraint(
   }
 
   // Check whether the declaration is available in a newer platform version.
-  auto rangeAndAttr = AvailabilityInference::availableRangeAndAttr(decl);
-  if (!availabilityContext.getPlatformRange().isContainedIn(rangeAndAttr.first))
-    return AvailabilityConstraint::forIntroducedInNewerVersion(
-        decl->getSemanticAvailableAttr(rangeAndAttr.second).value());
+  if (auto rangeAttr = decl->getAvailableAttrForPlatformIntroduction()) {
+    auto range = rangeAttr->getIntroducedRange(ctx);
+    if (!availabilityContext.getPlatformRange().isContainedIn(range))
+      return AvailabilityConstraint::forIntroducedInNewerVersion(*rangeAttr);
+  }
 
   return std::nullopt;
 }