AST: Introduce Decl::getUnavailableAttr().

tshortli · tshortli · commit 3e50a90c45c2 · 2024-12-02T07:35:58.000-08:00
It replaces `DeclAttr::getUnavailable()` and `AvailableAttr::isUnavailable()`
as the designated way to query for the attribute that makes a decl unavailable.
diff --git a/include/swift/AST/Attr.h b/include/swift/AST/Attr.h
@@ -809,12 +809,6 @@ class AvailableAttr : public DeclAttribute {
         Bits.AvailableAttr.PlatformAgnostic);
   }
 
-  /// Determine if a given declaration should be considered unavailable given
-  /// the current settings.
-  ///
-  /// \returns The attribute responsible for making the declaration unavailable.
-  static const AvailableAttr *isUnavailable(const Decl *D);
-
   /// Returns true if the availability applies to a specific
   /// platform.
   bool hasPlatform() const { return getPlatform() != PlatformKind::none; }
@@ -2946,11 +2940,6 @@ class DeclAttributes {
   findMostSpecificActivePlatform(const ASTContext &ctx,
                                  bool ignoreAppExtensions = false) const;
 
-  /// Returns the first @available attribute that indicates
-  /// a declaration is unavailable, or null otherwise.
-  const AvailableAttr *getUnavailable(const ASTContext &ctx,
-                                      bool ignoreAppExtensions = false) const;
-
   /// Returns the first @available attribute that indicates
   /// a declaration is deprecated on all deployment targets, or null otherwise.
   const AvailableAttr *getDeprecated(const ASTContext &ctx) const;
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -1390,7 +1390,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   /// and its DeclContext does not.
   bool isOutermostPrivateOrFilePrivateScope() const;
 
-  /// Returns true if the decl is always unavailable in this compilation
+  /// Returns true if the decl is always unavailable in the current compilation
   /// context. For example, the decl could be marked explicitly unavailable on
   /// either the current platform or in the current language mode. Returns false
   /// for declarations that are only _potentially_ unavailable because of a
@@ -1399,7 +1399,13 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   ///
   /// Note that this query only considers the attributes that are attached
   /// directly to this decl (or the extension it is declared in, if applicable).
-  bool isUnavailable() const;
+  bool isUnavailable() const { return getUnavailableAttr() != nullptr; }
+
+  /// If the decl is always unavailable in the current compilation
+  /// context, returns the attribute attached to the decl (or its parent
+  /// extension) that makes it unavailable.
+  const AvailableAttr *
+  getUnavailableAttr(bool ignoreAppExtensions = false) const;
 
   /// Retrieve the @available attribute that provides the OS version range that
   /// this declaration is available in.
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -2150,8 +2150,6 @@ bool ShouldPrintChecker::shouldPrint(const Pattern *P,
 }
 
 bool isNonSendableExtension(const Decl *D) {
-  ASTContext &ctx = D->getASTContext();
-
   const ExtensionDecl *ED = dyn_cast<ExtensionDecl>(D);
   if (!ED || !ED->isUnavailable())
     return false;
diff --git a/lib/AST/Attr.cpp b/lib/AST/Attr.cpp
@@ -427,52 +427,6 @@ DeclAttributes::findMostSpecificActivePlatform(const ASTContext &ctx,
   return bestAttr;
 }
 
-const AvailableAttr *
-DeclAttributes::getUnavailable(const ASTContext &ctx,
-                               bool ignoreAppExtensions) const {
-  const AvailableAttr *conditional = nullptr;
-  const AvailableAttr *bestActive =
-      findMostSpecificActivePlatform(ctx, ignoreAppExtensions);
-
-  for (auto Attr : *this)
-    if (auto AvAttr = dyn_cast<AvailableAttr>(Attr)) {
-      if (AvAttr->isInvalid())
-        continue;
-
-      // If this is a platform-specific attribute and it isn't the most
-      // specific attribute for the current platform, we're done.
-      if (AvAttr->hasPlatform() &&
-          (!bestActive || AvAttr != bestActive))
-        continue;
-
-      // If this attribute doesn't apply to the active platform, we're done.
-      if (!AvAttr->isActivePlatform(ctx) &&
-          !AvAttr->isLanguageVersionSpecific() &&
-          !AvAttr->isPackageDescriptionVersionSpecific())
-        continue;
-
-      if (ignoreAppExtensions &&
-          isApplicationExtensionPlatform(AvAttr->getPlatform()))
-        continue;
-
-      // Unconditional unavailable.
-      if (AvAttr->isUnconditionallyUnavailable())
-        return AvAttr;
-
-      switch (AvAttr->getVersionAvailability(ctx)) {
-      case AvailableVersionComparison::Available:
-      case AvailableVersionComparison::PotentiallyUnavailable:
-        break;
-
-      case AvailableVersionComparison::Obsoleted:
-      case AvailableVersionComparison::Unavailable:
-        conditional = AvAttr;
-        break;
-      }
-    }
-  return conditional;
-}
-
 const AvailableAttr *
 DeclAttributes::getDeprecated(const ASTContext &ctx) const {
   const AvailableAttr *conditional = nullptr;
@@ -2440,25 +2394,6 @@ AvailableVersionComparison AvailableAttr::getVersionAvailability(
   return AvailableVersionComparison::Available;
 }
 
-const AvailableAttr *AvailableAttr::isUnavailable(const Decl *D) {
-  ASTContext &ctx = D->getASTContext();
-  if (auto attr = D->getAttrs().getUnavailable(ctx))
-    return attr;
-
-  // If D is an extension member, check if the extension is unavailable.
-  //
-  // Skip decls imported from Clang, they could be associated to the wrong
-  // extension and inherit undesired unavailability. The ClangImporter
-  // associates Objective-C protocol members to the first category where the
-  // protocol is directly or indirectly adopted, no matter its availability
-  // and the availability of other categories. rdar://problem/53956555
-  if (!D->getClangNode())
-    if (auto ext = dyn_cast<ExtensionDecl>(D->getDeclContext()))
-        return AvailableAttr::isUnavailable(ext);
-
-  return nullptr;
-}
-
 SpecializeAttr::SpecializeAttr(SourceLoc atLoc, SourceRange range,
                                TrailingWhereClause *clause, bool exported,
                                SpecializationKind kind,
diff --git a/lib/AST/Availability.cpp b/lib/AST/Availability.cpp
@@ -486,14 +486,71 @@ bool Decl::isAvailableAsSPI() const {
   return AvailabilityInference::isAvailableAsSPI(this);
 }
 
-bool Decl::isUnavailable() const { return AvailableAttr::isUnavailable(this); }
+static const AvailableAttr *
+getDeclUnavailableAttr(const Decl *D, bool ignoreAppExtensions) {
+  auto &ctx = D->getASTContext();
+  auto attrs = D->getAttrs();
+  const AvailableAttr *result = nullptr;
+  const AvailableAttr *bestActive =
+      attrs.findMostSpecificActivePlatform(ctx, ignoreAppExtensions);
+
+  for (auto attr :
+       D->getAttrs().getAttributes<AvailableAttr, /*AllowInvalid=*/false>()) {
+    // 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;
+
+    // Unconditional unavailable.
+    if (attr->isUnconditionallyUnavailable())
+      return attr;
+
+    switch (attr->getVersionAvailability(ctx)) {
+    case AvailableVersionComparison::Available:
+    case AvailableVersionComparison::PotentiallyUnavailable:
+      break;
+
+    case AvailableVersionComparison::Obsoleted:
+    case AvailableVersionComparison::Unavailable:
+      result = attr;
+      break;
+    }
+  }
+  return result;
+}
+
+const AvailableAttr *Decl::getUnavailableAttr(bool ignoreAppExtensions) const {
+  if (auto attr = getDeclUnavailableAttr(this, ignoreAppExtensions))
+    return attr;
+
+  // If D is an extension member, check if the extension is unavailable.
+  //
+  // Skip decls imported from Clang, they could be associated to the wrong
+  // extension and inherit undesired unavailability. The ClangImporter
+  // associates Objective-C protocol members to the first category where the
+  // protocol is directly or indirectly adopted, no matter its availability
+  // and the availability of other categories. rdar://problem/53956555
+  if (!getClangNode())
+    if (auto ext = dyn_cast<ExtensionDecl>(getDeclContext()))
+      return ext->getUnavailableAttr(ignoreAppExtensions);
+
+  return nullptr;
+}
 
 std::optional<AvailableAttrDeclPair>
 SemanticUnavailableAttrRequest::evaluate(Evaluator &evaluator, const Decl *decl,
                                          bool ignoreAppExtensions) const {
   // Directly marked unavailable.
-  if (auto attr = decl->getAttrs().getUnavailable(decl->getASTContext(),
-                                                  ignoreAppExtensions))
+  if (auto attr = decl->getUnavailableAttr(ignoreAppExtensions))
     return std::make_pair(attr, decl);
 
   if (auto *parent =
diff --git a/lib/AST/AvailabilityContext.cpp b/lib/AST/AvailabilityContext.cpp
@@ -57,7 +57,7 @@ bool AvailabilityContext::PlatformInfo::constrainWith(const Decl *decl) {
   if (auto range = AvailabilityInference::annotatedAvailableRange(decl))
     isConstrained |= constrainRange(Range, *range);
 
-  if (auto *attr = decl->getAttrs().getUnavailable(ctx)) {
+  if (auto *attr = decl->getUnavailableAttr()) {
     isConstrained |= constrainUnavailability(attr->getPlatform());
     isConstrained |=
         CONSTRAIN_BOOL(IsUnavailableInEmbedded, attr->isForEmbedded());
diff --git a/lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp b/lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp
@@ -911,14 +911,13 @@ static bool eliminateSwitchDispatchOnUnavailableElements(
   if (!ED->hasCasesUnavailableDuringLowering())
     return false;
 
-  ASTContext &ctx = BB.getModule().getASTContext();
   SILLocation Loc = SWI->getLoc();
   bool DidRemoveUnavailableCase = false;
 
   SmallVector<std::pair<EnumElementDecl *, SILBasicBlock *>, 4> NewCaseBBs;
   for (unsigned i : range(SWI.getNumCases())) {
     auto CaseBB = SWI.getCase(i);
-    auto availableAtr = CaseBB.first->getAttrs().getUnavailable(ctx);
+    auto availableAtr = CaseBB.first->getUnavailableAttr();
 
     if (availableAtr && availableAtr->isUnconditionallyUnavailable()) {
       // Mark the basic block as potentially unreachable.
diff --git a/lib/Sema/TypeCheckAvailability.cpp b/lib/Sema/TypeCheckAvailability.cpp
@@ -370,7 +370,7 @@ static bool isInsideCompatibleUnavailableDeclaration(
 
 const AvailableAttr *
 ExportContext::shouldDiagnoseDeclAsUnavailable(const Decl *D) const {
-  auto attr = AvailableAttr::isUnavailable(D);
+  auto attr = D->getUnavailableAttr();
   if (!attr)
     return nullptr;
 
@@ -2929,11 +2929,10 @@ static bool diagnoseExplicitUnavailability(const ValueDecl *D, SourceRange R,
                                            const ExportContext &Where,
                                            const Expr *call,
                                            DeclAvailabilityFlags Flags) {
-  return diagnoseExplicitUnavailability(D, R, Where, Flags,
-                                        [=](InFlightDiagnostic &diag) {
-    fixItAvailableAttrRename(diag, R, D, AvailableAttr::isUnavailable(D),
-                             call);
-  });
+  return diagnoseExplicitUnavailability(
+      D, R, Where, Flags, [=](InFlightDiagnostic &diag) {
+        fixItAvailableAttrRename(diag, R, D, D->getUnavailableAttr(), call);
+      });
 }
 
 /// Represents common information needed to emit diagnostics about explicitly
@@ -3110,7 +3109,7 @@ swift::getUnsatisfiedAvailabilityConstraint(
   if (isa<GenericTypeParamDecl>(decl))
     return std::nullopt;
 
-  if (auto attr = AvailableAttr::isUnavailable(decl)) {
+  if (auto attr = decl->getUnavailableAttr()) {
     if (isInsideCompatibleUnavailableDeclaration(decl, availabilityContext,
                                                  attr))
       return std::nullopt;
@@ -4043,7 +4042,7 @@ bool ExprAvailabilityWalker::diagnoseDeclRefAvailability(
   if (D->getModuleContext()->isBuiltinModule())
     return false;
 
-  if (auto *attr = AvailableAttr::isUnavailable(D)) {
+  if (auto *attr = D->getUnavailableAttr()) {
     if (diagnoseIncDecRemoval(D, R, attr))
       return true;
     if (isa_and_nonnull<ApplyExpr>(call) &&
diff --git a/lib/Sema/TypeCheckDeclObjC.cpp b/lib/Sema/TypeCheckDeclObjC.cpp
@@ -3314,8 +3314,6 @@ class ObjCImplementationChecker {
     if (!VD)
       return;
 
-    ASTContext &ctx = VD->getASTContext();
-
     // Also skip overrides, unless they override an unavailable decl, which
     // makes them not formally overrides anymore.
     if (VD->getOverriddenDecl() && !VD->getOverriddenDecl()->isUnavailable())
diff --git a/lib/Sema/TypeCheckDeclOverride.cpp b/lib/Sema/TypeCheckDeclOverride.cpp
@@ -242,7 +242,7 @@ bool swift::isOverrideBasedOnType(const ValueDecl *decl, Type declTy,
 
 static bool isUnavailableInAllVersions(ValueDecl *decl) {
   ASTContext &ctx = decl->getASTContext();
-  auto *attr = decl->getAttrs().getUnavailable(ctx);
+  auto *attr = decl->getUnavailableAttr();
 
   if (!attr)
     return false;
@@ -1946,9 +1946,8 @@ checkOverrideUnavailability(ValueDecl *override, ValueDecl *base) {
     }
   }
 
-  auto &ctx = override->getASTContext();
-  auto *baseUnavailableAttr = base->getAttrs().getUnavailable(ctx);
-  auto *overrideUnavailableAttr = override->getAttrs().getUnavailable(ctx);
+  auto *baseUnavailableAttr = base->getUnavailableAttr();
+  auto *overrideUnavailableAttr = override->getUnavailableAttr();
 
   if (baseUnavailableAttr && !overrideUnavailableAttr)
     return {OverrideUnavailabilityStatus::BaseUnavailable, baseUnavailableAttr};
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -4357,7 +4357,7 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
     }
 
     case CheckKind::Unavailable: {
-      auto *attr = requirement->getAttrs().getUnavailable(getASTContext());
+      auto *attr = requirement->getUnavailableAttr();
       diagnoseOverrideOfUnavailableDecl(witness, requirement, attr);
       break;
     }
@@ -4415,7 +4415,7 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
         [witness, requirement](NormalProtocolConformance *conformance) {
           auto &diags = witness->getASTContext().Diags;
           SourceLoc diagLoc = getLocForDiagnosingWitness(conformance, witness);
-          auto *attr = AvailableAttr::isUnavailable(witness);
+          auto *attr = witness->getUnavailableAttr();
           EncodedDiagnosticMessage EncodedMessage(attr->Message);
           diags.diagnose(diagLoc, diag::witness_unavailable, witness,
                          conformance->getProtocol(), EncodedMessage.Message);
diff --git a/lib/SymbolGraphGen/SymbolGraph.cpp b/lib/SymbolGraphGen/SymbolGraph.cpp
@@ -839,7 +839,7 @@ bool SymbolGraph::isImplicitlyPrivate(const Decl *D,
   return false;
 }
 
-/// FIXME: This should use AvailableAttr::isUnavailable() or similar.
+/// FIXME: 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)) {
diff --git a/lib/SymbolGraphGen/SymbolGraphASTWalker.cpp b/lib/SymbolGraphGen/SymbolGraphASTWalker.cpp
@@ -111,8 +111,7 @@ SymbolGraph *SymbolGraphASTWalker::getModuleSymbolGraph(const Decl *D) {
 }
 
 static bool isUnavailableOrObsoletedOnPlatform(const Decl *D) {
-  if (const auto *Avail =
-        D->getAttrs().getUnavailable(D->getASTContext())) {
+  if (const auto *Avail = D->getUnavailableAttr()) {
     if (Avail->getPlatform() != PlatformKind::none)
       return true;
   }

Original file line number	Diff line number	Diff line change
`@@ -2150,8 +2150,6 @@ bool ShouldPrintChecker::shouldPrint(const Pattern *P,`
`2150`	`2150`	`}`
`2151`	`2151`
`2152`	`2152`	`bool isNonSendableExtension(const Decl *D) {`
`2153`		`- ASTContext &ctx = D->getASTContext();`
`2154`		`-`
`2155`	`2153`	`const ExtensionDecl *ED = dyn_cast<ExtensionDecl>(D);`
`2156`	`2154`	`if (!ED \|\| !ED->isUnavailable())`
`2157`	`2155`	`return false;`