Merge pull request #78485 from tshortli/adopt-semantic-available-attr-part-3

AST: Remove most platform queries from `AvailableAttr`

Author: tshortli

include/swift/AST/Attr.h

@@ -813,23 +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; }
-
-  /// Returns the string for the platform of the attribute.
-  StringRef platformString() const {
-    return swift::platformString(getPlatform());
-  }
-
-  /// Returns the human-readable string for the platform of the attribute.
-  StringRef prettyPlatformString() const {
-    return swift::prettyPlatformString(getPlatform());
-  }
-
-  /// Returns true if this attribute is active given the current platform.
-  bool isActivePlatform(const ASTContext &ctx) const;
-
   /// Create an AvailableAttr that indicates specific availability
   /// for all platforms.
   static AvailableAttr *
@@ -3239,7 +3222,7 @@ class SemanticAvailableAttr final {
 
   /// Returns the effective range in which the declaration with this attribute
   /// was introduced.
-  AvailabilityRange getIntroducedRange(ASTContext &Ctx) const;
+  AvailabilityRange getIntroducedRange(const ASTContext &Ctx) const;
 
   /// The version tuple written in source for the `deprecated:` component.
   std::optional<llvm::VersionTuple> getDeprecated() const {
@@ -3313,6 +3296,9 @@ class SemanticAvailableAttr final {
   /// compilation context.
   bool isActive(ASTContext &ctx) const;
 
+  /// Whether this attribute was spelled `@_spi_available`.
+  bool isSPI() const { return attr->isSPI(); }
+
   bool operator==(const SemanticAvailableAttr &other) const {
     return other.attr == attr;
   }

include/swift/AST/AvailabilityDomain.h

@@ -88,7 +88,7 @@ class AvailabilityDomain final {
 
   /// Returns true if this domain is considered active in the current
   /// compilation context.
-  bool isActive(ASTContext &ctx) const;
+  bool isActive(const ASTContext &ctx) const;
 
   /// Returns the string to use in diagnostics to identify the domain. May
   /// return an empty string.

include/swift/AST/AvailabilityInference.h

@@ -24,9 +24,9 @@
 
 namespace swift {
 class ASTContext;
-class AvailableAttr;
 class BackDeployedAttr;
 class Decl;
+class SemanticAvailableAttr;
 
 class AvailabilityInference {
 public:
@@ -63,26 +63,26 @@ class AvailabilityInference {
   /// values to the re-mapped platform's, if using a fallback platform.
   /// Returns `true` if a remap occured.
   static bool updateIntroducedPlatformForFallback(
-      const AvailableAttr *attr, const ASTContext &Ctx,
+      const SemanticAvailableAttr &attr, const ASTContext &Ctx,
       llvm::StringRef &Platform, llvm::VersionTuple &PlatformVer);
 
   /// For the attribute's deprecation version, update the platform and version
   /// values to the re-mapped platform's, if using a fallback platform.
   /// Returns `true` if a remap occured.
   static bool updateDeprecatedPlatformForFallback(
-      const AvailableAttr *attr, const ASTContext &Ctx,
+      const SemanticAvailableAttr &attr, const ASTContext &Ctx,
       llvm::StringRef &Platform, llvm::VersionTuple &PlatformVer);
 
   /// For the attribute's obsoletion version, update the platform and version
   /// values to the re-mapped platform's, if using a fallback platform.
   /// Returns `true` if a remap occured.
   static bool updateObsoletedPlatformForFallback(
-      const AvailableAttr *attr, const ASTContext &Ctx,
+      const SemanticAvailableAttr &attr, const ASTContext &Ctx,
       llvm::StringRef &Platform, llvm::VersionTuple &PlatformVer);
 
-  static void updatePlatformStringForFallback(
-      const AvailableAttr *attr, const ASTContext &Ctx,
-      llvm::StringRef &Platform);
+  static void updatePlatformStringForFallback(const SemanticAvailableAttr &attr,
+                                              const ASTContext &Ctx,
+                                              llvm::StringRef &Platform);
 
   /// For the attribute's before version, update the platform and version
   /// values to the re-mapped platform's, if using a fallback platform.

lib/APIDigester/ModuleAnalyzerNodes.cpp

@@ -1339,16 +1339,14 @@ std::optional<uint8_t> SDKContext::getFixedBinaryOrder(ValueDecl *VD) const {
 // check for if it has @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 static bool isABIPlaceHolder(Decl *D) {
   llvm::SmallSet<PlatformKind, 4> Platforms;
-  for (auto semanticAttr : D->getSemanticAvailableAttrs()) {
-    auto attr = semanticAttr.getParsedAttr();
-    auto domain = semanticAttr.getDomain();
-    if (domain.isPlatform() && attr->Introduced &&
-        attr->Introduced->getMajor() == 9999) {
-      Platforms.insert(attr->getPlatform());
+  for (auto attr : D->getSemanticAvailableAttrs()) {
+    if (attr.isPlatformSpecific() && attr.getIntroduced().has_value() &&
+        attr.getIntroduced()->getMajor() == 9999) {
+      Platforms.insert(attr.getPlatform());
     }
   }
 
-  // FIXME: This probably isn't correct anymore, now that visionOS exists
+  // FIXME: [availability] This probably isn't correct now that visionOS exists
   return Platforms.size() == 4;
 }
 

lib/AST/Attr.cpp

@@ -421,7 +421,7 @@ void DeclAttributes::dump(const Decl *D) const {
 LLVM_READONLY
 static bool isShortAvailable(const SemanticAvailableAttr &attr) {
   auto parsedAttr = attr.getParsedAttr();
-  if (parsedAttr->isSPI())
+  if (attr.isSPI())
     return false;
 
   if (!attr.getIntroduced().has_value())
@@ -741,11 +741,16 @@ static void printDifferentiableAttrArguments(
 
 /// Returns the `PlatformKind` referenced by \p attr if applicable, or
 /// `std::nullopt` otherwise.
-static std::optional<PlatformKind>
-referencedPlatform(const DeclAttribute *attr) {
+static std::optional<PlatformKind> referencedPlatform(const DeclAttribute *attr,
+                                                      const Decl *D) {
   switch (attr->getKind()) {
   case DeclAttrKind::Available:
-    return static_cast<const AvailableAttr *>(attr)->getPlatform();
+    if (auto semanticAttr = D->getSemanticAvailableAttr(
+            static_cast<const AvailableAttr *>(attr))) {
+      if (semanticAttr->isPlatformSpecific())
+        return semanticAttr->getPlatform();
+    }
+    return std::nullopt;
   case DeclAttrKind::BackDeployed:
     return static_cast<const BackDeployedAttr *>(attr)->Platform;
   case DeclAttrKind::OriginallyDefinedIn:
@@ -757,8 +762,8 @@ referencedPlatform(const DeclAttribute *attr) {
 
 /// Returns true if \p attr contains a reference to a `PlatformKind` that should
 /// be considered SPI.
-static bool referencesSPIPlatform(const DeclAttribute *attr) {
-  if (auto platform = referencedPlatform(attr))
+static bool referencesSPIPlatform(const DeclAttribute *attr, const Decl *D) {
+  if (auto platform = referencedPlatform(attr, D))
     return isPlatformSPI(*platform);
   return false;
 }
@@ -805,7 +810,7 @@ void DeclAttributes::print(ASTPrinter &Printer, const PrintOptions &Options,
     // In the public interfaces of -library-level=api modules, skip attributes
     // that reference SPI platforms.
     if (Options.printPublicInterface() && libraryLevelAPI &&
-        referencesSPIPlatform(DA))
+        referencesSPIPlatform(DA, D))
       continue;
 
     // If we're supposed to suppress expanded macros, check whether this is
@@ -1172,21 +1177,20 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
   }
 
   case DeclAttrKind::Available: {
-    auto Attr = cast<AvailableAttr>(this);
-    auto SemanticAttr = D->getSemanticAvailableAttr(Attr);
-    if (!SemanticAttr)
+    auto Attr = D->getSemanticAvailableAttr(cast<AvailableAttr>(this));
+    if (!Attr)
       return false;
 
     if (Options.printPublicInterface() && Attr->isSPI()) {
-      assert(Attr->hasPlatform());
-      assert(Attr->Introduced.has_value());
+      assert(Attr->isPlatformSpecific());
+      assert(Attr->getIntroduced().has_value());
       Printer.printAttrName("@available");
       Printer << "(";
-      Printer << Attr->platformString();
+      Printer << Attr->getDomain().getNameForAttributePrinting();
       Printer << ", unavailable)";
       break;
     }
-    if (Attr->isForEmbedded()) {
+    if (Attr->getParsedAttr()->isForEmbedded()) {
       std::string atUnavailableInEmbedded =
           (llvm::Twine("@") + UNAVAILABLE_IN_EMBEDDED_ATTRNAME).str();
       Printer.printAttrName(atUnavailableInEmbedded);
@@ -1200,7 +1204,7 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
       Printer.printAttrName("@available");
     }
     Printer << "(";
-    printAvailableAttr(D, *SemanticAttr, Printer, Options);
+    printAvailableAttr(D, *Attr, Printer, Options);
     Printer << ")";
     break;
   }
@@ -2148,10 +2152,6 @@ AvailableAttr::createPlatformAgnostic(ASTContext &C,
       /*SPI=*/false);
 }
 
-bool AvailableAttr::isActivePlatform(const ASTContext &ctx) const {
-  return isPlatformActive(getPlatform(), ctx.LangOpts);
-}
-
 bool BackDeployedAttr::isActivePlatform(const ASTContext &ctx,
                                         bool forTargetVariant) const {
   return isPlatformActive(Platform, ctx.LangOpts, forTargetVariant);
@@ -2261,7 +2261,7 @@ SemanticAvailableAttr::getVersionAvailability(const ASTContext &ctx) const {
   StringRef ObsoletedPlatform;
   llvm::VersionTuple RemappedObsoletedVersion;
   if (AvailabilityInference::updateObsoletedPlatformForFallback(
-          attr, ctx, ObsoletedPlatform, RemappedObsoletedVersion))
+          *this, ctx, ObsoletedPlatform, RemappedObsoletedVersion))
     ObsoletedVersion = RemappedObsoletedVersion;
 
   // If this entity was obsoleted before or at the query platform version,
@@ -2273,7 +2273,7 @@ SemanticAvailableAttr::getVersionAvailability(const ASTContext &ctx) const {
   StringRef IntroducedPlatform;
   llvm::VersionTuple RemappedIntroducedVersion;
   if (AvailabilityInference::updateIntroducedPlatformForFallback(
-          attr, ctx, IntroducedPlatform, RemappedIntroducedVersion))
+          *this, ctx, IntroducedPlatform, RemappedIntroducedVersion))
     IntroducedVersion = RemappedIntroducedVersion;
 
   // If this entity was introduced after the query version and we're doing a

lib/AST/Availability.cpp

@@ -156,7 +156,7 @@ static void mergeWithInferredAvailability(SemanticAvailableAttr Attr,
   // The merge of two introduction versions is the maximum of the two versions.
   if (mergeIntoInferredVersion(Attr.getIntroduced(), Inferred.Introduced,
                                std::max)) {
-    Inferred.IsSPI = ParsedAttr->isSPI();
+    Inferred.IsSPI = Attr.isSPI();
   }
 
   // The merge of deprecated and obsoleted versions takes the minimum.
@@ -345,10 +345,10 @@ getRemappedDeprecatedObsoletedVersionForFallbackPlatform(
 }
 
 bool AvailabilityInference::updateIntroducedPlatformForFallback(
-    const AvailableAttr *attr, const ASTContext &Ctx, llvm::StringRef &Platform,
-    llvm::VersionTuple &PlatformVer) {
-  std::optional<llvm::VersionTuple> IntroducedVersion = attr->Introduced;
-  if (attr->getPlatform() == PlatformKind::iOS &&
+    const SemanticAvailableAttr &attr, const ASTContext &Ctx,
+    llvm::StringRef &Platform, llvm::VersionTuple &PlatformVer) {
+  std::optional<llvm::VersionTuple> IntroducedVersion = attr.getIntroduced();
+  if (attr.getPlatform() == PlatformKind::iOS &&
       IntroducedVersion.has_value() &&
       isPlatformActive(PlatformKind::visionOS, Ctx.LangOpts)) {
     // We re-map the iOS introduced version to the corresponding visionOS version
@@ -365,10 +365,10 @@ bool AvailabilityInference::updateIntroducedPlatformForFallback(
 }
 
 bool AvailabilityInference::updateDeprecatedPlatformForFallback(
-    const AvailableAttr *attr, const ASTContext &Ctx, llvm::StringRef &Platform,
-    llvm::VersionTuple &PlatformVer) {
-  std::optional<llvm::VersionTuple> DeprecatedVersion = attr->Deprecated;
-  if (attr->getPlatform() == PlatformKind::iOS &&
+    const SemanticAvailableAttr &attr, const ASTContext &Ctx,
+    llvm::StringRef &Platform, llvm::VersionTuple &PlatformVer) {
+  std::optional<llvm::VersionTuple> DeprecatedVersion = attr.getDeprecated();
+  if (attr.getPlatform() == PlatformKind::iOS &&
       DeprecatedVersion.has_value() &&
       isPlatformActive(PlatformKind::visionOS, Ctx.LangOpts)) {
     // We re-map the iOS deprecated version to the corresponding visionOS version
@@ -385,11 +385,10 @@ bool AvailabilityInference::updateDeprecatedPlatformForFallback(
 }
 
 bool AvailabilityInference::updateObsoletedPlatformForFallback(
-    const AvailableAttr *attr, const ASTContext &Ctx, llvm::StringRef &Platform,
-    llvm::VersionTuple &PlatformVer) {
-  std::optional<llvm::VersionTuple> ObsoletedVersion = attr->Obsoleted;
-  if (attr->getPlatform() == PlatformKind::iOS &&
-      ObsoletedVersion.has_value() &&
+    const SemanticAvailableAttr &attr, const ASTContext &Ctx,
+    llvm::StringRef &Platform, llvm::VersionTuple &PlatformVer) {
+  std::optional<llvm::VersionTuple> ObsoletedVersion = attr.getObsoleted();
+  if (attr.getPlatform() == PlatformKind::iOS && ObsoletedVersion.has_value() &&
       isPlatformActive(PlatformKind::visionOS, Ctx.LangOpts)) {
     // We re-map the iOS obsoleted version to the corresponding visionOS version
     auto PotentiallyRemappedObsoletedVersion =
@@ -405,8 +404,9 @@ bool AvailabilityInference::updateObsoletedPlatformForFallback(
 }
 
 void AvailabilityInference::updatePlatformStringForFallback(
-    const AvailableAttr *attr, const ASTContext &Ctx, llvm::StringRef &Platform) {
-  if (attr->getPlatform() == PlatformKind::iOS &&
+    const SemanticAvailableAttr &attr, const ASTContext &Ctx,
+    llvm::StringRef &Platform) {
+  if (attr.getPlatform() == PlatformKind::iOS &&
       isPlatformActive(PlatformKind::visionOS, Ctx.LangOpts)) {
     Platform = swift::prettyPlatformString(PlatformKind::visionOS);
   }
@@ -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:
@@ -530,8 +531,7 @@ std::optional<SemanticAvailableAttr> Decl::getDeprecatedAttr() const {
     StringRef deprecatedPlatform;
     llvm::VersionTuple remappedDeprecatedVersion;
     if (AvailabilityInference::updateDeprecatedPlatformForFallback(
-            attr.getParsedAttr(), ctx, deprecatedPlatform,
-            remappedDeprecatedVersion))
+            attr, ctx, deprecatedPlatform, remappedDeprecatedVersion))
       deprecatedVersion = remappedDeprecatedVersion;
 
     if (!deprecatedVersion.has_value())
@@ -821,21 +821,24 @@ AvailabilityRange AvailabilityInference::availableRange(const Decl *D) {
 
 bool AvailabilityInference::isAvailableAsSPI(const Decl *D) {
   if (auto attr = D->getAvailableAttrForPlatformIntroduction())
-    return attr->getParsedAttr()->isSPI();
+    return attr->isSPI();
 
   return false;
 }
 
 AvailabilityRange
-SemanticAvailableAttr::getIntroducedRange(ASTContext &Ctx) const {
+SemanticAvailableAttr::getIntroducedRange(const ASTContext &Ctx) const {
+  assert(domain.isActive(Ctx));
+
   auto *attr = getParsedAttr();
-  assert(attr->isActivePlatform(Ctx));
+  if (!attr->Introduced.has_value())
+    return AvailabilityRange::alwaysAvailable();
 
   llvm::VersionTuple IntroducedVersion = attr->Introduced.value();
-  StringRef Platform = attr->prettyPlatformString();
+  StringRef Platform;
   llvm::VersionTuple RemappedIntroducedVersion;
   if (AvailabilityInference::updateIntroducedPlatformForFallback(
-      attr, Ctx, Platform, RemappedIntroducedVersion))
+          *this, Ctx, Platform, RemappedIntroducedVersion))
     IntroducedVersion = RemappedIntroducedVersion;
 
   return AvailabilityRange{VersionRange::allGTE(IntroducedVersion)};

lib/AST/AvailabilityDomain.cpp

@@ -16,7 +16,7 @@
 
 using namespace swift;
 
-bool AvailabilityDomain::isActive(ASTContext &ctx) const {
+bool AvailabilityDomain::isActive(const ASTContext &ctx) const {
   switch (kind) {
   case Kind::Universal:
   case Kind::SwiftLanguage: