AST: Introduce Decl::getSemanticAvailableAttr().

This convenience returns an optional `SemanticAvailableAttr` (since in the
future, lookup of the `AvailabilityDomain` can fail). It replaces
`Decl::getDomainForAvailableAttr()`, since most callers will need to form a
`SemanticAvailableAttr` with the resulting domain anyways.

Author: tshortli

include/swift/AST/Attr.h

@@ -3205,6 +3205,18 @@ class SemanticAvailableAttr final {
 
   const AvailableAttr *getParsedAttr() const { return attr; }
   const AvailabilityDomain getDomain() const { return domain; }
+
+  /// Returns the platform kind that the attribute applies to, or
+  /// `PlatformKind::none` if the attribute is not platform specific.
+  bool isPlatformSpecific() const { return domain.isPlatform(); }
+
+  /// Returns the platform kind that the attribute applies to, or
+  /// `PlatformKind::none` if the attribute is not platform specific.
+  PlatformKind getPlatformKind() const { return domain.getPlatformKind(); }
+
+  /// Returns true if this attribute is considered active in the current
+  /// compilation context.
+  bool isActive(ASTContext &ctx) const;
 };
 
 /// An iterable range of `SemanticAvailableAttr`s.

include/swift/AST/Decl.h

@@ -1401,9 +1401,12 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   SemanticAvailableAttributes
   getSemanticAvailableAttrs(bool includeInactive = true) const;
 
-  /// Returns the availability domain associated with the given `AvailableAttr`
-  /// that is attached to this decl.
-  AvailabilityDomain getDomainForAvailableAttr(const AvailableAttr *attr) const;
+  /// Returns the SemanticAvailableAttr associated with the given
+  /// `AvailableAttr` that is attached to this decl. Returns `std::nullopt` if a
+  /// valid semantic version of the attribute cannot be constructed (e.g. the
+  /// domain cannot be resolved).
+  std::optional<SemanticAvailableAttr>
+  getSemanticAvailableAttr(const AvailableAttr *attr) const;
 
   /// Returns the active platform-specific `@available` attribute for this decl.
   /// There may be multiple `@available` attributes that are relevant to the

lib/AST/Attr.cpp

@@ -826,15 +826,18 @@ void DeclAttributes::print(ASTPrinter &Printer, const PrintOptions &Options,
     // Be careful not to coalesce `@available(swift 5)` with other short
     // `available' attributes.
     if (auto *availableAttr = dyn_cast<AvailableAttr>(DA)) {
-      auto domain = D->getDomainForAvailableAttr(availableAttr);
-      auto semanticAttr = SemanticAvailableAttr(availableAttr, domain);
-      if (isShortAvailable(semanticAttr)) {
+      auto semanticAttr = D->getSemanticAvailableAttr(availableAttr);
+      if (!semanticAttr)
+        continue;
+
+      auto domain = semanticAttr->getDomain();
+      if (isShortAvailable(*semanticAttr)) {
         if (domain.isSwiftLanguage())
-          swiftVersionAvailableAttribute.emplace(semanticAttr);
+          swiftVersionAvailableAttribute.emplace(*semanticAttr);
         else if (domain.isPackageDescription())
-          packageDescriptionVersionAvailableAttribute.emplace(semanticAttr);
+          packageDescriptionVersionAvailableAttribute.emplace(*semanticAttr);
         else
-          shortAvailableAttributes.push_back(semanticAttr);
+          shortAvailableAttributes.push_back(*semanticAttr);
 
         continue;
       }
@@ -912,6 +915,10 @@ ParsedDeclAttrFilter::operator()(const DeclAttribute *Attr) const {
   return Attr;
 }
 
+bool SemanticAvailableAttr::isActive(ASTContext &ctx) const {
+  return domain.isActive(ctx);
+}
+
 std::optional<SemanticAvailableAttr>
 SemanticAvailableAttributes::Filter::operator()(
     const DeclAttribute *attr) const {
@@ -922,11 +929,14 @@ SemanticAvailableAttributes::Filter::operator()(
   if (availableAttr->isInvalid())
     return std::nullopt;
 
-  auto domain = decl->getDomainForAvailableAttr(availableAttr);
-  if (!includeInactive && !domain.isActive(decl->getASTContext()))
+  auto semanticAttr = decl->getSemanticAvailableAttr(availableAttr);
+  if (!semanticAttr)
     return std::nullopt;
 
-  return SemanticAvailableAttr(availableAttr, domain);
+  if (!includeInactive && !semanticAttr->isActive(decl->getASTContext()))
+    return std::nullopt;
+
+  return *semanticAttr;
 }
 
 static void printAvailableAttr(const Decl *D,
@@ -1164,8 +1174,9 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
 
   case DeclAttrKind::Available: {
     auto Attr = cast<AvailableAttr>(this);
-    auto Domain = D->getDomainForAvailableAttr(Attr);
-    auto SemanticAttr = SemanticAvailableAttr(Attr, Domain);
+    auto SemanticAttr = D->getSemanticAvailableAttr(Attr);
+    if (!SemanticAttr)
+      return false;
 
     if (Options.printPublicInterface() && Attr->isSPI()) {
       assert(Attr->hasPlatform());
@@ -1190,7 +1201,7 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
       Printer.printAttrName("@available");
     }
     Printer << "(";
-    printAvailableAttr(D, SemanticAttr, Printer, Options);
+    printAvailableAttr(D, *SemanticAttr, Printer, Options);
     Printer << ")";
     break;
   }
@@ -1286,8 +1297,8 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
       Printer << "target: " << target << ", ";
     SmallVector<SemanticAvailableAttr, 8> semanticAvailAttrs;
     for (auto availAttr : attr->getAvailableAttrs()) {
-      auto domain = D->getDomainForAvailableAttr(availAttr);
-      semanticAvailAttrs.push_back(SemanticAvailableAttr(availAttr, domain));
+      if (auto semanticAttr = D->getSemanticAvailableAttr(availAttr))
+        semanticAvailAttrs.push_back(*semanticAttr);
     }
 
     if (!semanticAvailAttrs.empty()) {

lib/AST/Availability.cpp

@@ -464,6 +464,35 @@ bool Decl::isAvailableAsSPI() const {
   return AvailabilityInference::isAvailableAsSPI(this);
 }
 
+SemanticAvailableAttributes
+Decl::getSemanticAvailableAttrs(bool includeInactive) const {
+  return SemanticAvailableAttributes(getAttrs(), this, includeInactive);
+}
+
+std::optional<SemanticAvailableAttr>
+Decl::getSemanticAvailableAttr(const AvailableAttr *attr) const {
+  auto domainForAvailableAttr = [](const AvailableAttr *attr) {
+    if (attr->hasPlatform())
+      return AvailabilityDomain::forPlatform(attr->getPlatform());
+
+    switch (attr->getPlatformAgnosticAvailability()) {
+    case PlatformAgnosticAvailabilityKind::Deprecated:
+    case PlatformAgnosticAvailabilityKind::Unavailable:
+    case PlatformAgnosticAvailabilityKind::NoAsync:
+    case PlatformAgnosticAvailabilityKind::None:
+      return AvailabilityDomain::forUniversal();
+
+    case PlatformAgnosticAvailabilityKind::UnavailableInSwift:
+    case PlatformAgnosticAvailabilityKind::SwiftVersionSpecific:
+      return AvailabilityDomain::forSwiftLanguage();
+
+    case PlatformAgnosticAvailabilityKind::PackageDescriptionVersionSpecific:
+      return AvailabilityDomain::forPackageDescription();
+    }
+  };
+  return SemanticAvailableAttr(attr, domainForAvailableAttr(attr));
+}
+
 const AvailableAttr *
 Decl::getActiveAvailableAttrForCurrentPlatform(bool ignoreAppExtensions) const {
   const AvailableAttr *bestAttr = nullptr;

lib/AST/AvailabilityDomain.cpp

@@ -16,32 +16,6 @@
 
 using namespace swift;
 
-SemanticAvailableAttributes
-Decl::getSemanticAvailableAttrs(bool includeInactive) const {
-  return SemanticAvailableAttributes(getAttrs(), this, includeInactive);
-}
-
-AvailabilityDomain
-Decl::getDomainForAvailableAttr(const AvailableAttr *attr) const {
-  if (attr->hasPlatform())
-    return AvailabilityDomain::forPlatform(attr->getPlatform());
-
-  switch (attr->getPlatformAgnosticAvailability()) {
-  case PlatformAgnosticAvailabilityKind::Deprecated:
-  case PlatformAgnosticAvailabilityKind::Unavailable:
-  case PlatformAgnosticAvailabilityKind::NoAsync:
-  case PlatformAgnosticAvailabilityKind::None:
-    return AvailabilityDomain::forUniversal();
-
-  case PlatformAgnosticAvailabilityKind::UnavailableInSwift:
-  case PlatformAgnosticAvailabilityKind::SwiftVersionSpecific:
-    return AvailabilityDomain::forSwiftLanguage();
-
-  case PlatformAgnosticAvailabilityKind::PackageDescriptionVersionSpecific:
-    return AvailabilityDomain::forPackageDescription();
-  }
-}
-
 bool AvailabilityDomain::isActive(ASTContext &ctx) const {
   switch (kind) {
   case Kind::Universal:

lib/Sema/TypeCheckAvailability.cpp

@@ -3061,8 +3061,11 @@ getExplicitUnavailabilityDiagnosticInfo(const Decl *decl,
   if (!attr)
     return std::nullopt;
 
+  auto semanticAttr = decl->getSemanticAvailableAttr(attr);
+  if (!semanticAttr)
+    return std::nullopt;
+
   ASTContext &ctx = decl->getASTContext();
-  auto domain = decl->getDomainForAvailableAttr(attr);
 
   switch (attr->getVersionAvailability(ctx)) {
   case AvailableVersionComparison::Available:
@@ -3075,17 +3078,18 @@ getExplicitUnavailabilityDiagnosticInfo(const Decl *decl,
         attr->Introduced.has_value()) {
       return UnavailabilityDiagnosticInfo(
           UnavailabilityDiagnosticInfo::Status::IntroducedInVersion, attr,
-          domain);
+          semanticAttr->getDomain());
     } else {
       return UnavailabilityDiagnosticInfo(
           UnavailabilityDiagnosticInfo::Status::AlwaysUnavailable, attr,
-          domain);
+          semanticAttr->getDomain());
     }
     break;
 
   case AvailableVersionComparison::Obsoleted:
     return UnavailabilityDiagnosticInfo(
-        UnavailabilityDiagnosticInfo::Status::Obsoleted, attr, domain);
+        UnavailabilityDiagnosticInfo::Status::Obsoleted, attr,
+        semanticAttr->getDomain());
   }
 }