AST: Remove IsSPI from AvailabilityContext.

It only existed to make `Decl::isAvailableAsSPI()` convenient to implement.

NFC.

Author: tshortli

include/swift/AST/Availability.h

@@ -230,13 +230,10 @@ class UnavailabilityReason {
 /// to create an \c AvailabilityContext, rather than creating one directly.
 class AvailabilityContext {
   VersionRange OSVersion;
-  std::optional<bool> SPI;
 
 public:
   /// Creates a context that requires certain versions of the target OS.
-  explicit AvailabilityContext(VersionRange OSVersion,
-                               std::optional<bool> SPI = std::nullopt)
-      : OSVersion(OSVersion), SPI(SPI) {}
+  explicit AvailabilityContext(VersionRange OSVersion) : OSVersion(OSVersion) {}
 
   /// Creates a context that imposes the constraints of the ASTContext's
   /// deployment target.
@@ -332,12 +329,9 @@ class AvailabilityContext {
     OSVersion.unionWith(other.getOSVersion());
   }
 
-  bool isAvailableAsSPI() const { return SPI && *SPI; }
-
   /// Returns a representation of this range as a string for debugging purposes.
   std::string getAsString() const {
-    return "AvailabilityContext(" + OSVersion.getAsString() +
-           (isAvailableAsSPI() ? ", spi" : "") + ")";
+    return "AvailabilityContext(" + OSVersion.getAsString() + ")";
   }
 };
 
@@ -358,9 +352,12 @@ class AvailabilityInference {
   static AvailabilityContext inferForType(Type t);
 
   /// Returns the context where a declaration is available
-  ///  We assume a declaration without an annotation is always available.
+  /// We assume a declaration without an annotation is always available.
   static AvailabilityContext availableRange(const Decl *D, ASTContext &C);
 
+  /// Returns true is the declaration is `@_spi_available`.
+  static bool isAvailableAsSPI(const Decl *D, ASTContext &C);
+
   /// Returns the availability context for a declaration with the given
   /// @available attribute.
   ///

lib/AST/Availability.cpp

@@ -423,8 +423,7 @@ AvailabilityInference::annotatedAvailableRange(const Decl *D, ASTContext &Ctx) {
 }
 
 bool Decl::isAvailableAsSPI() const {
-  return AvailabilityInference::availableRange(this, getASTContext())
-    .isAvailableAsSPI();
+  return AvailabilityInference::isAvailableAsSPI(this, getASTContext());
 }
 
 std::optional<AvailableAttrDeclPair>
@@ -550,13 +549,10 @@ AvailabilityInference::annotatedAvailableRangeForAttr(const SpecializeAttr* attr
   return AvailabilityContext::alwaysAvailable();
 }
 
-AvailabilityContext AvailabilityInference::availableRange(const Decl *D,
-                                                          ASTContext &Ctx) {
-  std::optional<AvailabilityContext> AnnotatedRange =
-      annotatedAvailableRange(D, Ctx);
-  if (AnnotatedRange.has_value()) {
-    return AnnotatedRange.value();
-  }
+static const AvailableAttr *attrForAvailableRange(const Decl *D,
+                                                  ASTContext &Ctx) {
+  if (auto attr = AvailabilityInference::attrForAnnotatedAvailableRange(D, Ctx))
+    return attr;
 
   // Unlike other declarations, extensions can be used without referring to them
   // by name (they don't have one) in the source. For this reason, when checking
@@ -568,16 +564,30 @@ AvailabilityContext AvailabilityInference::availableRange(const Decl *D,
 
   DeclContext *DC = D->getDeclContext();
   if (auto *ED = dyn_cast<ExtensionDecl>(DC)) {
-    AnnotatedRange = annotatedAvailableRange(ED, Ctx);
-    if (AnnotatedRange.has_value()) {
-      return AnnotatedRange.value();
-    }
+    if (auto attr =
+            AvailabilityInference::attrForAnnotatedAvailableRange(ED, Ctx))
+      return attr;
   }
 
+  return nullptr;
+}
+
+AvailabilityContext AvailabilityInference::availableRange(const Decl *D,
+                                                          ASTContext &Ctx) {
+  if (auto attr = attrForAvailableRange(D, Ctx))
+    return availableRange(attr, Ctx);
+
   // Treat unannotated declarations as always available.
   return AvailabilityContext::alwaysAvailable();
 }
 
+bool AvailabilityInference::isAvailableAsSPI(const Decl *D, ASTContext &Ctx) {
+  if (auto attr = attrForAvailableRange(D, Ctx))
+    return attr->IsSPI;
+
+  return false;
+}
+
 AvailabilityContext
 AvailabilityInference::availableRange(const AvailableAttr *attr,
                                       ASTContext &Ctx) {
@@ -590,8 +600,7 @@ AvailabilityInference::availableRange(const AvailableAttr *attr,
       attr, Ctx, Platform, RemappedIntroducedVersion))
     IntroducedVersion = RemappedIntroducedVersion;
 
-  return AvailabilityContext{VersionRange::allGTE(IntroducedVersion),
-                             attr->IsSPI};
+  return AvailabilityContext{VersionRange::allGTE(IntroducedVersion)};
 }
 
 namespace {