AST: Remove AvailableAttr::hasPlatform().

Use SemanticAvailableAttr::isPlatformSpecific() instead.

Author: tshortli

include/swift/AST/Attr.h

@@ -813,10 +813,6 @@ class AvailableAttr : public DeclAttribute {
         Bits.AvailableAttr.PlatformAgnostic);
   }
 
-  /// Returns true if the availability applies to a specific
-  /// platform.
-  bool hasPlatform() const { return getPlatform() != PlatformKind::none; }
-
   /// Create an AvailableAttr that indicates specific availability
   /// for all platforms.
   static AvailableAttr *

lib/AST/Availability.cpp

@@ -468,8 +468,9 @@ Decl::getSemanticAvailableAttrs(bool includeInactive) const {
 std::optional<SemanticAvailableAttr>
 Decl::getSemanticAvailableAttr(const AvailableAttr *attr) const {
   auto domainForAvailableAttr = [](const AvailableAttr *attr) {
-    if (attr->hasPlatform())
-      return AvailabilityDomain::forPlatform(attr->getPlatform());
+    auto platform = attr->getPlatform();
+    if (platform != PlatformKind::none)
+      return AvailabilityDomain::forPlatform(platform);
 
     switch (attr->getPlatformAgnosticAvailability()) {
     case PlatformAgnosticAvailabilityKind::Deprecated:

lib/Sema/TypeCheckAttr.cpp

@@ -2276,16 +2276,19 @@ getSemanticAvailableRangeDeclAndAttr(const Decl *decl) {
   return std::nullopt;
 }
 
-void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
+void AttributeChecker::visitAvailableAttr(AvailableAttr *parsedAttr) {
   if (Ctx.LangOpts.DisableAvailabilityChecking)
     return;
 
-  // FIXME: This seems like it could be diagnosed during parsing instead.
-  while (attr->isSPI()) {
-    if (attr->hasPlatform() && attr->Introduced.has_value())
-      break;
-    diagnoseAndRemoveAttr(attr, diag::spi_available_malformed);
-    break;
+  auto attr = D->getSemanticAvailableAttr(parsedAttr);
+  if (!attr)
+    return;
+
+  if (attr->isSPI()) {
+    if (!attr->isPlatformSpecific() || !attr->getIntroduced().has_value()) {
+      diagnoseAndRemoveAttr(parsedAttr, diag::spi_available_malformed);
+      return;
+    }
   }
 
   if (attr->isNoAsync()) {
@@ -2312,7 +2315,7 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
     // deinit's may not be unavailable from async contexts
     if (isa<DestructorDecl>(D)) {
       D->getASTContext().Diags.diagnose(
-          D->getLoc(), diag::invalid_decl_attribute, attr);
+          D->getLoc(), diag::invalid_decl_attribute, parsedAttr);
     }
   }
 
@@ -2323,32 +2326,28 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
     return;
 
   // The remaining diagnostics are only for attributes that are active.
-  auto semanticAttr = D->getSemanticAvailableAttr(attr);
-  if (!semanticAttr)
-    return;
-
-  if (!semanticAttr->isActive(Ctx))
+  if (!attr->isActive(Ctx))
     return;
 
   // Make sure there isn't a more specific attribute we should be using instead.
   // getActiveAvailableAttrForCurrentPlatform() is O(N), so only do this if
   // we're checking an iOS attribute while building for macCatalyst.
   if (attr->getPlatform() == PlatformKind::iOS &&
       isPlatformActive(PlatformKind::macCatalyst, Ctx.LangOpts)) {
-    if (semanticAttr != D->getActiveAvailableAttrForCurrentPlatform()) {
+    if (attr != D->getActiveAvailableAttrForCurrentPlatform()) {
       return;
     }
   }
 
   if (attr->getPlatform() == PlatformKind::iOS &&
       isPlatformActive(PlatformKind::visionOS, Ctx.LangOpts)) {
-    if (semanticAttr != D->getActiveAvailableAttrForCurrentPlatform()) {
+    if (attr != D->getActiveAvailableAttrForCurrentPlatform()) {
       return;
     }
   }
 
-  SourceLoc attrLoc = attr->getLocation();
-  auto versionAvailability = semanticAttr->getVersionAvailability(Ctx);
+  SourceLoc attrLoc = parsedAttr->getLocation();
+  auto versionAvailability = attr->getVersionAvailability(Ctx);
   if (versionAvailability == AvailableVersionComparison::Obsoleted ||
       versionAvailability == AvailableVersionComparison::Unavailable) {
     if (auto cannotBeUnavailable =
@@ -2360,7 +2359,7 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
     if (auto *PD = dyn_cast<ProtocolDecl>(DC)) {
       if (auto *VD = dyn_cast<ValueDecl>(D)) {
         if (VD->isProtocolRequirement() && !PD->isObjC()) {
-          diagnoseAndRemoveAttr(attr,
+          diagnoseAndRemoveAttr(parsedAttr,
                                 diag::unavailable_method_non_objc_protocol);
           return;
         }
@@ -2370,15 +2369,15 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
 
   // The remaining diagnostics are only for attributes with introduced versions
   // for specific platforms.
-  if (!attr->hasPlatform() || !attr->Introduced.has_value())
+  if (!attr->isPlatformSpecific() || !attr->getIntroduced().has_value())
     return;
 
   // Find the innermost enclosing declaration with an availability
   // range annotation and ensure that this attribute's available version range
   // 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 = semanticAttr->getIntroducedRange(Ctx);
+  AvailabilityRange AttrRange = attr->getIntroducedRange(Ctx);
 
   if (auto *parent = getEnclosingDeclForDecl(D)) {
     if (auto enclosingAvailable =
@@ -2399,7 +2398,7 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
             limit = DiagnosticBehavior::Warning;
         }
         diagnose(D->isImplicit() ? enclosingDecl->getLoc()
-                                 : attr->getLocation(),
+                                 : parsedAttr->getLocation(),
                  diag::availability_decl_more_than_enclosing,
                  D->getDescriptiveKind())
             .limitBehavior(limit);

lib/SymbolGraphGen/SymbolGraph.cpp

@@ -839,16 +839,14 @@ bool SymbolGraph::isImplicitlyPrivate(const Decl *D,
   return false;
 }
 
-/// FIXME: This should use Decl::getUnavailableAttr() or similar.
+/// FIXME: [availability] This should use Decl::getUnavailableAttr() or similar.
 bool SymbolGraph::isUnconditionallyUnavailableOnAllPlatforms(const Decl *D) const {
-  return llvm::any_of(D->getAttrs(), [](const auto *Attr) { 
-    if (const auto *AvAttr = dyn_cast<AvailableAttr>(Attr)) {
-      return !AvAttr->hasPlatform()
-        && AvAttr->isUnconditionallyUnavailable();
-    }
+  for (auto Attr : D->getSemanticAvailableAttrs()) {
+    if (!Attr.isPlatformSpecific() && Attr.isUnconditionallyUnavailable())
+      return true;
+  }
 
-    return false;
-  });
+  return false;
 }
 
 /// Returns `true` if the symbol should be included as a node in the graph.