AST: Introduce Decl::getSemanticAvailableAttrs().

tshortli · tshortli · commit 0288eaa3b75b · 2024-12-19T08:40:00.000-08:00
This new attribute iterator returned from the query makes it simpler to
implement algorithms that need access to both the `AvailableAttr *` and its
corresponding `AvailabilityDomain`. This is also work towards making it
possible to return an optional `AvailabilityDomain` from
`Decl::getDomainForAvailableAttr()`.
diff --git a/include/swift/AST/Attr.h b/include/swift/AST/Attr.h
@@ -20,6 +20,7 @@
 #include "swift/AST/ASTAllocated.h"
 #include "swift/AST/AttrKind.h"
 #include "swift/AST/AutoDiff.h"
+#include "swift/AST/AvailabilityDomain.h"
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/DeclNameLoc.h"
 #include "swift/AST/Identifier.h"
@@ -3190,6 +3191,52 @@ class ParsedDeclAttributes {
   }
 };
 
+/// A wrapper for `AvailableAttr` that is enriched with additional semantic
+/// informaton, like its corresponding `AvailabilityDomain`.
+class SemanticAvailableAttr final {
+  const AvailableAttr *attr;
+  const AvailabilityDomain domain;
+
+public:
+  SemanticAvailableAttr(const AvailableAttr *attr, AvailabilityDomain domain)
+      : attr(attr), domain(domain) {}
+
+  const AvailableAttr *getParsedAttr() const { return attr; }
+  const AvailabilityDomain getDomain() const { return domain; }
+};
+
+/// An iterable range of `SemanticAvailableAttr`s.
+class SemanticAvailableAttributes {
+public:
+  class Filter final {
+    const Decl *decl;
+    bool includeInactive;
+
+  public:
+    Filter(const Decl *decl, bool includeInactive)
+        : decl(decl), includeInactive(includeInactive) {}
+
+    std::optional<SemanticAvailableAttr>
+    operator()(const DeclAttribute *attr) const;
+  };
+
+  using Range =
+      OptionalTransformRange<iterator_range<DeclAttributes::const_iterator>,
+                             Filter>;
+
+private:
+  Range attrRange;
+
+public:
+  SemanticAvailableAttributes(const DeclAttributes &attrs, const Decl *decl,
+                              bool includeInactive = false)
+      : attrRange(make_range(attrs.begin(), attrs.end()),
+                  Filter(decl, includeInactive)) {}
+
+  Range::iterator begin() const { return attrRange.begin(); }
+  Range::iterator end() const { return attrRange.end(); }
+};
+
 class alignas(1 << AttrAlignInBits) TypeAttribute
     : public ASTAllocated<TypeAttribute> {
 protected:
diff --git a/include/swift/AST/AvailabilityDomain.h b/include/swift/AST/AvailabilityDomain.h
@@ -22,6 +22,7 @@
 #include "swift/Basic/LLVM.h"
 
 namespace swift {
+class ASTContext;
 
 /// Represents a dimension of availability (e.g. macOS platform or Swift
 /// language mode).
@@ -88,6 +89,10 @@ class AvailabilityDomain final {
     return platform;
   }
 
+  /// Returns true if this domain is considered active in the current
+  /// compilation context.
+  bool isActive(ASTContext &ctx) const;
+
   /// Returns the string to use in diagnostics to identify the domain. May
   /// return an empty string.
   llvm::StringRef getNameForDiagnostics() const;
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -1395,6 +1395,12 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   /// and its DeclContext does not.
   bool isOutermostPrivateOrFilePrivateScope() const;
 
+  /// Returns an iterable list of the valid `AvailableAttr` and
+  /// `AvailabilityDomain` pairs. Unless \p includeInactive is true, attributes
+  /// that are considered inactive for the compilation context are filtered out.
+  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;
diff --git a/lib/APIDigester/ModuleAnalyzerNodes.cpp b/lib/APIDigester/ModuleAnalyzerNodes.cpp
@@ -1339,14 +1339,16 @@ 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 *ATT: D->getAttrs()) {
-    if (auto *AVA = dyn_cast<AvailableAttr>(ATT)) {
-      if (AVA->getPlatform() != PlatformKind::none && AVA->Introduced &&
-          AVA->Introduced->getMajor() == 9999) {
-        Platforms.insert(AVA->getPlatform());
-      }
+  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());
     }
   }
+
+  // FIXME: This probably isn't correct anymore, now that visionOS exists
   return Platforms.size() == 4;
 }
 
@@ -1361,11 +1363,11 @@ static bool isABIPlaceholderRecursive(Decl *D) {
 StringRef SDKContext::getPlatformIntroVersion(Decl *D, PlatformKind Kind) {
   if (!D)
     return StringRef();
-  for (auto *ATT: D->getAttrs()) {
-    if (auto *AVA = dyn_cast<AvailableAttr>(ATT)) {
-      if (AVA->getPlatform() == Kind && AVA->Introduced) {
-        return buffer(AVA->Introduced->getAsString());
-      }
+  for (auto semanticAttr : D->getSemanticAvailableAttrs()) {
+    auto attr = semanticAttr.getParsedAttr();
+    auto domain = semanticAttr.getDomain();
+    if (domain.getPlatformKind() == Kind && attr->Introduced) {
+      return buffer(attr->Introduced->getAsString());
     }
   }
   return StringRef();
@@ -1374,11 +1376,12 @@ StringRef SDKContext::getPlatformIntroVersion(Decl *D, PlatformKind Kind) {
 StringRef SDKContext::getLanguageIntroVersion(Decl *D) {
   if (!D)
     return StringRef();
-  for (auto *ATT: D->getAttrs()) {
-    if (auto *AVA = dyn_cast<AvailableAttr>(ATT)) {
-      if (AVA->isLanguageVersionSpecific() && AVA->Introduced) {
-        return buffer(AVA->Introduced->getAsString());
-      }
+  for (auto semanticAttr : D->getSemanticAvailableAttrs()) {
+    auto attr = semanticAttr.getParsedAttr();
+    auto domain = semanticAttr.getDomain();
+
+    if (domain.isSwiftLanguage() && attr->Introduced) {
+      return buffer(attr->Introduced->getAsString());
     }
   }
   return getLanguageIntroVersion(D->getDeclContext()->getAsDecl());
diff --git a/lib/AST/Attr.cpp b/lib/AST/Attr.cpp
@@ -909,6 +909,23 @@ ParsedDeclAttrFilter::operator()(const DeclAttribute *Attr) const {
   return Attr;
 }
 
+std::optional<SemanticAvailableAttr>
+SemanticAvailableAttributes::Filter::operator()(
+    const DeclAttribute *attr) const {
+  auto availableAttr = dyn_cast<AvailableAttr>(attr);
+  if (!availableAttr)
+    return std::nullopt;
+
+  if (availableAttr->isInvalid())
+    return std::nullopt;
+
+  auto domain = decl->getDomainForAvailableAttr(availableAttr);
+  if (!includeInactive && !domain.isActive(decl->getASTContext()))
+    return std::nullopt;
+
+  return SemanticAvailableAttr(availableAttr, domain);
+}
+
 static void printAvailableAttr(const Decl *D, const AvailableAttr *Attr,
                                ASTPrinter &Printer,
                                const PrintOptions &Options) {
diff --git a/lib/AST/Availability.cpp b/lib/AST/Availability.cpp
@@ -18,6 +18,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Attr.h"
 #include "swift/AST/AvailabilityConstraint.h"
+#include "swift/AST/AvailabilityDomain.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/PlatformKind.h"
 #include "swift/AST/TypeCheckRequests.h"
@@ -432,22 +433,19 @@ bool AvailabilityInference::updateBeforePlatformForFallback(
 
 const AvailableAttr *
 AvailabilityInference::attrForAnnotatedAvailableRange(const Decl *D) {
-  ASTContext &Ctx = D->getASTContext();
   const AvailableAttr *bestAvailAttr = nullptr;
 
   D = abstractSyntaxDeclForAvailableAttribute(D);
 
-  for (auto Attr : D->getAttrs()) {
-    auto *AvailAttr = dyn_cast<AvailableAttr>(Attr);
-    if (AvailAttr == nullptr || !AvailAttr->Introduced.has_value() ||
-        !AvailAttr->isActivePlatform(Ctx) ||
-        AvailAttr->isLanguageVersionSpecific() ||
-        AvailAttr->isPackageDescriptionVersionSpecific()) {
+  for (auto semanticAttr :
+       D->getSemanticAvailableAttrs(/*includingInactive=*/false)) {
+    auto *attr = semanticAttr.getParsedAttr();
+
+    if (!attr->hasPlatform() || !attr->Introduced.has_value())
       continue;
-    }
 
-    if (isBetterThan(AvailAttr, bestAvailAttr))
-      bestAvailAttr = AvailAttr;
+    if (isBetterThan(attr, bestAvailAttr))
+      bestAvailAttr = attr;
   }
 
   return bestAvailAttr;
@@ -468,12 +466,13 @@ bool Decl::isAvailableAsSPI() const {
 
 const AvailableAttr *
 Decl::getActiveAvailableAttrForCurrentPlatform(bool ignoreAppExtensions) const {
-  auto &ctx = getASTContext();
   const AvailableAttr *bestAttr = nullptr;
 
-  for (auto attr :
-       getAttrs().getAttributes<AvailableAttr, /*AllowInvalid=*/false>()) {
-    if (!attr->hasPlatform() || !attr->isActivePlatform(ctx))
+  for (auto semanticAttr :
+       getSemanticAvailableAttrs(/*includingInactive=*/false)) {
+    auto attr = semanticAttr.getParsedAttr();
+
+    if (!attr->hasPlatform())
       continue;
 
     if (ignoreAppExtensions &&
@@ -493,17 +492,14 @@ Decl::getActiveAvailableAttrForCurrentPlatform(bool ignoreAppExtensions) const {
 
 const AvailableAttr *Decl::getDeprecatedAttr() const {
   auto &ctx = getASTContext();
-  auto attrs = getAttrs();
   const AvailableAttr *result = nullptr;
   const AvailableAttr *bestActive = getActiveAvailableAttrForCurrentPlatform();
 
-  for (auto attr :
-       attrs.getAttributes<AvailableAttr, /*AllowInvalid=*/false>()) {
-    if (attr->hasPlatform() && (!bestActive || attr != bestActive))
-      continue;
+  for (auto semanticAttr :
+       getSemanticAvailableAttrs(/*includingInactive=*/false)) {
+    auto attr = semanticAttr.getParsedAttr();
 
-    if (!attr->isActivePlatform(ctx) && !attr->isLanguageVersionSpecific() &&
-        !attr->isPackageDescriptionVersionSpecific())
+    if (attr->hasPlatform() && (!bestActive || attr != bestActive))
       continue;
 
     // Unconditional deprecated.
@@ -534,17 +530,14 @@ const AvailableAttr *Decl::getDeprecatedAttr() const {
 
 const AvailableAttr *Decl::getSoftDeprecatedAttr() const {
   auto &ctx = getASTContext();
-  auto attrs = getAttrs();
   const AvailableAttr *result = nullptr;
   const AvailableAttr *bestActive = getActiveAvailableAttrForCurrentPlatform();
 
-  for (auto attr :
-       attrs.getAttributes<AvailableAttr, /*AllowInvalid=*/false>()) {
-    if (attr->hasPlatform() && (!bestActive || attr != bestActive))
-      continue;
+  for (auto semanticAttr :
+       getSemanticAvailableAttrs(/*includingInactive=*/false)) {
+    auto attr = semanticAttr.getParsedAttr();
 
-    if (!attr->isActivePlatform(ctx) && !attr->isLanguageVersionSpecific() &&
-        !attr->isPackageDescriptionVersionSpecific())
+    if (attr->hasPlatform() && (!bestActive || attr != bestActive))
       continue;
 
     std::optional<llvm::VersionTuple> deprecatedVersion = attr->Deprecated;
@@ -560,19 +553,16 @@ const AvailableAttr *Decl::getSoftDeprecatedAttr() const {
 }
 
 const AvailableAttr *Decl::getNoAsyncAttr() const {
-  auto &ctx = getASTContext();
   const AvailableAttr *bestAttr = nullptr;
 
-  for (auto attr :
-       getAttrs().getAttributes<AvailableAttr, /*AllowInvalid=*/false>()) {
+  for (auto semanticAttr :
+       getSemanticAvailableAttrs(/*includingInactive=*/false)) {
+    auto attr = semanticAttr.getParsedAttr();
 
     if (attr->getPlatformAgnosticAvailability() !=
         PlatformAgnosticAvailabilityKind::NoAsync)
       continue;
 
-    if (attr->hasPlatform() && !attr->isActivePlatform(ctx))
-      continue;
-
     if (!bestAttr) {
       bestAttr = attr;
       continue;
@@ -597,9 +587,12 @@ const AvailableAttr *Decl::getNoAsyncAttr() const {
 
 bool Decl::isUnavailableInCurrentSwiftVersion() const {
   llvm::VersionTuple vers = getASTContext().LangOpts.EffectiveLanguageVersion;
-  for (auto attr :
-       getAttrs().getAttributes<AvailableAttr, /*AllowInvalid=*/false>()) {
-    if (attr->isLanguageVersionSpecific()) {
+  for (auto semanticAttr :
+       getSemanticAvailableAttrs(/*includingInactive=*/false)) {
+    auto attr = semanticAttr.getParsedAttr();
+    auto domain = semanticAttr.getDomain();
+
+    if (domain.isSwiftLanguage()) {
       if (attr->Introduced.has_value() && attr->Introduced.value() > vers)
         return true;
       if (attr->Obsoleted.has_value() && attr->Obsoleted.value() <= vers)
@@ -617,18 +610,15 @@ getDeclUnavailableAttr(const Decl *D, bool ignoreAppExtensions) {
   const AvailableAttr *bestActive =
       D->getActiveAvailableAttrForCurrentPlatform(ignoreAppExtensions);
 
-  for (auto attr :
-       D->getAttrs().getAttributes<AvailableAttr, /*AllowInvalid=*/false>()) {
+  for (auto semanticAttr :
+       D->getSemanticAvailableAttrs(/*includingInactive=*/false)) {
+    auto attr = semanticAttr.getParsedAttr();
+
     // If this is a platform-specific attribute and it isn't the most
     // specific attribute for the current platform, we're done.
     if (attr->hasPlatform() && (!bestActive || attr != bestActive))
       continue;
 
-    // If this attribute doesn't apply to the active platform, we're done.
-    if (!attr->isActivePlatform(ctx) && !attr->isLanguageVersionSpecific() &&
-        !attr->isPackageDescriptionVersionSpecific())
-      continue;
-
     if (ignoreAppExtensions &&
         isApplicationExtensionPlatform(attr->getPlatform()))
       continue;
diff --git a/lib/AST/AvailabilityDomain.cpp b/lib/AST/AvailabilityDomain.cpp
@@ -11,10 +11,16 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/AST/AvailabilityDomain.h"
+#include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 
 using namespace swift;
 
+SemanticAvailableAttributes
+Decl::getSemanticAvailableAttrs(bool includeInactive) const {
+  return SemanticAvailableAttributes(getAttrs(), this, includeInactive);
+}
+
 AvailabilityDomain
 Decl::getDomainForAvailableAttr(const AvailableAttr *attr) const {
   if (attr->hasPlatform())
@@ -36,6 +42,17 @@ Decl::getDomainForAvailableAttr(const AvailableAttr *attr) const {
   }
 }
 
+bool AvailabilityDomain::isActive(ASTContext &ctx) const {
+  switch (kind) {
+  case Kind::Universal:
+  case Kind::SwiftLanguage:
+  case Kind::PackageDescription:
+    return true;
+  case Kind::Platform:
+    return isPlatformActive(getPlatformKind(), ctx.LangOpts);
+  }
+}
+
 llvm::StringRef AvailabilityDomain::getNameForDiagnostics() const {
   switch (kind) {
   case Kind::Universal:
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -9278,7 +9278,9 @@ AbstractFunctionDecl *AbstractFunctionDecl::getAsyncAlternative() const {
   // `getAttrs` is in reverse source order, so the last attribute is the
   // first in source.
   AbstractFunctionDecl *alternative = nullptr;
-  for (const auto *attr : getAttrs().getAttributes<AvailableAttr>()) {
+  for (auto semanticAttr : getSemanticAvailableAttrs()) {
+    auto attr = semanticAttr.getParsedAttr();
+
     if (attr->isNoAsync())
       continue;
 
diff --git a/lib/Frontend/ModuleInterfaceSupport.cpp b/lib/Frontend/ModuleInterfaceSupport.cpp
@@ -451,7 +451,9 @@ class InheritedProtocolCollector {
 
     cache.emplace();
     while (D) {
-      for (auto *nextAttr : D->getAttrs().getAttributes<AvailableAttr>()) {
+      for (auto semanticAttr : D->getSemanticAvailableAttrs()) {
+        auto nextAttr = semanticAttr.getParsedAttr();
+
         // FIXME: This is just approximating the effects of nested availability
         // attributes for the same platform; formally they'd need to be merged.
         bool alreadyHasMoreSpecificAttrForThisPlatform =
diff --git a/lib/PrintAsClang/DeclAndTypePrinter.cpp b/lib/PrintAsClang/DeclAndTypePrinter.cpp
diff --git a/lib/Sema/TypeCheckConcurrency.cpp b/lib/Sema/TypeCheckConcurrency.cpp
diff --git a/lib/Sema/TypeCheckDeclPrimary.cpp b/lib/Sema/TypeCheckDeclPrimary.cpp
diff --git a/test/attr/attr_availability_async_rename.swift b/test/attr/attr_availability_async_rename.swift
