AST: Return SemanticAvailableAttr from Decl::getUnavailableAttr().

Author: tshortli

include/swift/AST/Attr.h

@@ -3244,6 +3244,9 @@ class SemanticAvailableAttr final {
     return getDomain().isPackageDescription() && isVersionSpecific();
   }
 
+  /// Whether this attribute was spelled `@_unavailableInEmbedded`.
+  bool isEmbeddedSpecific() const { return attr->isForEmbedded(); }
+
   /// Returns the active version from the AST context corresponding to
   /// the available kind. For example, this will return the effective language
   /// version for swift version-specific availability kind, PackageDescription

include/swift/AST/Decl.h

@@ -1443,12 +1443,12 @@ 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 { return getUnavailableAttr() != nullptr; }
+  bool isUnavailable() const { return getUnavailableAttr().has_value(); }
 
   /// 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 *
+  std::optional<SemanticAvailableAttr>
   getUnavailableAttr(bool ignoreAppExtensions = false) const;
 
   /// Returns true if the decl is effectively always unavailable in the current

lib/AST/Availability.cpp

@@ -610,45 +610,43 @@ bool Decl::isUnavailableInCurrentSwiftVersion() const {
   return false;
 }
 
-static const AvailableAttr *
+std::optional<SemanticAvailableAttr>
 getDeclUnavailableAttr(const Decl *D, bool ignoreAppExtensions) {
   auto &ctx = D->getASTContext();
-  const AvailableAttr *result = nullptr;
+  std::optional<SemanticAvailableAttr> result;
   auto bestActive =
       D->getActiveAvailableAttrForCurrentPlatform(ignoreAppExtensions);
 
-  for (auto semanticAttr :
-       D->getSemanticAvailableAttrs(/*includingInactive=*/false)) {
-    auto attr = semanticAttr.getParsedAttr();
-
+  for (auto attr : D->getSemanticAvailableAttrs(/*includingInactive=*/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 || semanticAttr != bestActive))
+    if (attr.isPlatformSpecific() && (!bestActive || attr != bestActive))
       continue;
 
     if (ignoreAppExtensions &&
-        isApplicationExtensionPlatform(attr->getPlatform()))
+        isApplicationExtensionPlatform(attr.getPlatform()))
       continue;
 
     // Unconditional unavailable.
-    if (attr->isUnconditionallyUnavailable())
+    if (attr.isUnconditionallyUnavailable())
       return attr;
 
-    switch (semanticAttr.getVersionAvailability(ctx)) {
+    switch (attr.getVersionAvailability(ctx)) {
     case AvailableVersionComparison::Available:
     case AvailableVersionComparison::PotentiallyUnavailable:
       break;
 
     case AvailableVersionComparison::Obsoleted:
     case AvailableVersionComparison::Unavailable:
-      result = attr;
+      result.emplace(attr);
       break;
     }
   }
   return result;
 }
 
-const AvailableAttr *Decl::getUnavailableAttr(bool ignoreAppExtensions) const {
+std::optional<SemanticAvailableAttr>
+Decl::getUnavailableAttr(bool ignoreAppExtensions) const {
   if (auto attr = getDeclUnavailableAttr(this, ignoreAppExtensions))
     return attr;
 
@@ -663,16 +661,15 @@ const AvailableAttr *Decl::getUnavailableAttr(bool ignoreAppExtensions) const {
     if (auto ext = dyn_cast<ExtensionDecl>(getDeclContext()))
       return ext->getUnavailableAttr(ignoreAppExtensions);
 
-  return nullptr;
+  return std::nullopt;
 }
 
 static bool isDeclCompletelyUnavailable(const Decl *decl) {
   // Don't trust unavailability on declarations from clang modules.
   if (isa<ClangModuleUnit>(decl->getDeclContext()->getModuleScopeContext()))
     return false;
 
-  auto *unavailableAttr =
-      decl->getUnavailableAttr(/*ignoreAppExtensions=*/true);
+  auto unavailableAttr = decl->getUnavailableAttr(/*ignoreAppExtensions=*/true);
   if (!unavailableAttr)
     return false;
 

lib/AST/AvailabilityContext.cpp

@@ -57,10 +57,10 @@ bool AvailabilityContext::PlatformInfo::constrainWith(const Decl *decl) {
   if (auto range = AvailabilityInference::annotatedAvailableRange(decl))
     isConstrained |= constrainRange(Range, *range);
 
-  if (auto *attr = decl->getUnavailableAttr()) {
+  if (auto attr = decl->getUnavailableAttr()) {
     isConstrained |= constrainUnavailability(attr->getPlatform());
     isConstrained |=
-        CONSTRAIN_BOOL(IsUnavailableInEmbedded, attr->isForEmbedded());
+        CONSTRAIN_BOOL(IsUnavailableInEmbedded, attr->isEmbeddedSpecific());
   }
 
   isConstrained |= CONSTRAIN_BOOL(IsDeprecated, decl->isDeprecated());

lib/Sema/TypeCheckAttr.cpp

@@ -4833,10 +4833,10 @@ void AttributeChecker::checkBackDeployedAttrs(
         // Find the attribute that makes the declaration unavailable.
         const Decl *attrDecl = D;
         do {
-          if (auto *unavailableAttr = attrDecl->getUnavailableAttr()) {
-            diagnose(unavailableAttr->AtLoc,
+          if (auto unavailableAttr = attrDecl->getUnavailableAttr()) {
+            diagnose(unavailableAttr->getParsedAttr()->AtLoc,
                      diag::availability_marked_unavailable, VD)
-                .highlight(unavailableAttr->getRange());
+                .highlight(unavailableAttr->getParsedAttr()->getRange());
             break;
           }
 

lib/Sema/TypeCheckAvailability.cpp

@@ -345,39 +345,39 @@ static bool computeContainedByDeploymentTarget(AvailabilityScope *scope,
 /// unconditional unavailable declaration for the same platform.
 static bool isInsideCompatibleUnavailableDeclaration(
     const Decl *D, AvailabilityContext availabilityContext,
-    const AvailableAttr *attr) {
+    const SemanticAvailableAttr &attr) {
   auto contextPlatform = availabilityContext.getUnavailablePlatformKind();
   if (!contextPlatform)
     return false;
 
-  if (!attr->isUnconditionallyUnavailable())
+  if (!attr.isUnconditionallyUnavailable())
     return false;
 
   // Refuse calling universally unavailable functions from unavailable code,
   // but allow the use of types.
-  PlatformKind declPlatform = attr->getPlatform();
-  if (declPlatform == PlatformKind::none && !attr->isForEmbedded() &&
+  PlatformKind declPlatform = attr.getPlatform();
+  if (declPlatform == PlatformKind::none && !attr.isEmbeddedSpecific() &&
       !isa<TypeDecl>(D) && !isa<ExtensionDecl>(D))
     return false;
 
   // @_unavailableInEmbedded declarations may be used in contexts that are
   // also @_unavailableInEmbedded.
-  if (attr->isForEmbedded())
+  if (attr.isEmbeddedSpecific())
     return availabilityContext.isUnavailableInEmbedded();
 
   return (*contextPlatform == PlatformKind::none ||
           *contextPlatform == declPlatform ||
           inheritsAvailabilityFromPlatform(declPlatform, *contextPlatform));
 }
 
-const AvailableAttr *
+std::optional<SemanticAvailableAttr>
 ExportContext::shouldDiagnoseDeclAsUnavailable(const Decl *D) const {
   auto attr = D->getUnavailableAttr();
   if (!attr)
-    return nullptr;
+    return std::nullopt;
 
-  if (isInsideCompatibleUnavailableDeclaration(D, Availability, attr))
-    return nullptr;
+  if (isInsideCompatibleUnavailableDeclaration(D, Availability, *attr))
+    return std::nullopt;
 
   return attr;
 }
@@ -2996,7 +2996,9 @@ static bool diagnoseExplicitUnavailability(const ValueDecl *D, SourceRange R,
                                            DeclAvailabilityFlags Flags) {
   return diagnoseExplicitUnavailability(
       D, R, Where, Flags, [=](InFlightDiagnostic &diag) {
-        fixItAvailableAttrRename(diag, R, D, D->getUnavailableAttr(), call);
+        auto attr = D->getUnavailableAttr();
+        assert(attr);
+        fixItAvailableAttrRename(diag, R, D, attr->getParsedAttr(), call);
       });
 }
 
@@ -3019,20 +3021,18 @@ class UnavailabilityDiagnosticInfo {
 
 private:
   Status DiagnosticStatus;
-  const AvailableAttr *Attr;
-  AvailabilityDomain Domain;
+  SemanticAvailableAttr Attr;
 
 public:
-  UnavailabilityDiagnosticInfo(Status status, const AvailableAttr *attr,
-                               AvailabilityDomain domain)
-      : DiagnosticStatus(status), Attr(attr), Domain(domain) {
-    assert(attr);
-  };
+  UnavailabilityDiagnosticInfo(Status status, const SemanticAvailableAttr &attr)
+      : DiagnosticStatus(status), Attr(attr) {};
 
   Status getStatus() const { return DiagnosticStatus; }
-  const AvailableAttr *getAttr() const { return Attr; }
-  AvailabilityDomain getDomain() const { return Domain; }
-  StringRef getDomainName() const { return Domain.getNameForDiagnostics(); }
+  const AvailableAttr *getAttr() const { return Attr.getParsedAttr(); }
+  AvailabilityDomain getDomain() const { return Attr.getDomain(); }
+  StringRef getDomainName() const {
+    return getDomain().getNameForDiagnostics();
+  }
 
   bool shouldHideDomainNameInUnversionedDiagnostics() const {
     switch (getDomain().getKind()) {
@@ -3057,39 +3057,32 @@ class UnavailabilityDiagnosticInfo {
 static std::optional<UnavailabilityDiagnosticInfo>
 getExplicitUnavailabilityDiagnosticInfo(const Decl *decl,
                                         const ExportContext &where) {
-  auto *attr = where.shouldDiagnoseDeclAsUnavailable(decl);
+  auto attr = where.shouldDiagnoseDeclAsUnavailable(decl);
   if (!attr)
     return std::nullopt;
 
-  auto semanticAttr = decl->getSemanticAvailableAttr(attr);
-  if (!semanticAttr)
-    return std::nullopt;
-
   ASTContext &ctx = decl->getASTContext();
 
-  switch (semanticAttr->getVersionAvailability(ctx)) {
+  switch (attr->getVersionAvailability(ctx)) {
   case AvailableVersionComparison::Available:
   case AvailableVersionComparison::PotentiallyUnavailable:
     llvm_unreachable("These aren't considered unavailable");
 
   case AvailableVersionComparison::Unavailable:
-    if ((semanticAttr->isSwiftLanguageModeSpecific() ||
-         semanticAttr->isPackageDescriptionVersionSpecific()) &&
-        attr->Introduced.has_value()) {
+    if ((attr->isSwiftLanguageModeSpecific() ||
+         attr->isPackageDescriptionVersionSpecific()) &&
+        attr->getIntroduced()) {
       return UnavailabilityDiagnosticInfo(
-          UnavailabilityDiagnosticInfo::Status::IntroducedInVersion, attr,
-          semanticAttr->getDomain());
+          UnavailabilityDiagnosticInfo::Status::IntroducedInVersion, *attr);
     } else {
       return UnavailabilityDiagnosticInfo(
-          UnavailabilityDiagnosticInfo::Status::AlwaysUnavailable, attr,
-          semanticAttr->getDomain());
+          UnavailabilityDiagnosticInfo::Status::AlwaysUnavailable, *attr);
     }
     break;
 
   case AvailableVersionComparison::Obsoleted:
     return UnavailabilityDiagnosticInfo(
-        UnavailabilityDiagnosticInfo::Status::Obsoleted, attr,
-        semanticAttr->getDomain());
+        UnavailabilityDiagnosticInfo::Status::Obsoleted, *attr);
   }
 }
 
@@ -3161,29 +3154,26 @@ swift::getUnsatisfiedAvailabilityConstraint(
     return std::nullopt;
 
   if (auto attr = decl->getUnavailableAttr()) {
-    auto semanticAttr = decl->getSemanticAvailableAttr(attr);
-    if (!semanticAttr)
-      return std::nullopt;
-
     if (isInsideCompatibleUnavailableDeclaration(decl, availabilityContext,
-                                                 attr))
+                                                 *attr))
       return std::nullopt;
 
-    switch (semanticAttr->getVersionAvailability(ctx)) {
+    auto parsedAttr = attr->getParsedAttr();
+    switch (attr->getVersionAvailability(ctx)) {
     case AvailableVersionComparison::Available:
     case AvailableVersionComparison::PotentiallyUnavailable:
       llvm_unreachable("Decl should be unavailable");
 
     case AvailableVersionComparison::Unavailable:
-      if ((semanticAttr->isSwiftLanguageModeSpecific() ||
-           semanticAttr->isPackageDescriptionVersionSpecific()) &&
-          attr->Introduced.has_value())
-        return AvailabilityConstraint::forRequiresVersion(attr);
+      if ((attr->isSwiftLanguageModeSpecific() ||
+           attr->isPackageDescriptionVersionSpecific()) &&
+          attr->getIntroduced().has_value())
+        return AvailabilityConstraint::forRequiresVersion(parsedAttr);
 
-      return AvailabilityConstraint::forAlwaysUnavailable(attr);
+      return AvailabilityConstraint::forAlwaysUnavailable(parsedAttr);
 
     case AvailableVersionComparison::Obsoleted:
-      return AvailabilityConstraint::forObsoleted(attr);
+      return AvailabilityConstraint::forObsoleted(parsedAttr);
     }
   }
 
@@ -4131,11 +4121,12 @@ bool ExprAvailabilityWalker::diagnoseDeclRefAvailability(
   if (D->getModuleContext()->isBuiltinModule())
     return false;
 
-  if (auto *attr = D->getUnavailableAttr()) {
-    if (diagnoseIncDecRemoval(D, R, attr))
+  if (auto attr = D->getUnavailableAttr()) {
+    auto parsedAttr = attr->getParsedAttr();
+    if (diagnoseIncDecRemoval(D, R, parsedAttr))
       return true;
     if (isa_and_nonnull<ApplyExpr>(call) &&
-        diagnoseMemoryLayoutMigration(D, R, attr, cast<ApplyExpr>(call)))
+        diagnoseMemoryLayoutMigration(D, R, parsedAttr, cast<ApplyExpr>(call)))
       return true;
   }
 

lib/Sema/TypeCheckAvailability.h

@@ -13,7 +13,7 @@
 #ifndef SWIFT_SEMA_TYPE_CHECK_AVAILABILITY_H
 #define SWIFT_SEMA_TYPE_CHECK_AVAILABILITY_H
 
-#include "swift/AST/AttrKind.h"
+#include "swift/AST/Attr.h"
 #include "swift/AST/AvailabilityConstraint.h"
 #include "swift/AST/AvailabilityContext.h"
 #include "swift/AST/DeclContext.h"
@@ -26,7 +26,6 @@
 
 namespace swift {
   class ApplyExpr;
-  class AvailableAttr;
   class Expr;
   class ClosureExpr;
   class InFlightDiagnostic;
@@ -198,7 +197,8 @@ class ExportContext {
   /// is not also unavailable in the same way, then this returns the specific
   /// `@available` attribute that makes the decl unavailable. Otherwise, returns
   /// nullptr.
-  const AvailableAttr *shouldDiagnoseDeclAsUnavailable(const Decl *decl) const;
+  std::optional<SemanticAvailableAttr>
+  shouldDiagnoseDeclAsUnavailable(const Decl *decl) const;
 };
 
 /// Check if a declaration is exported as part of a module's external interface.

lib/Sema/TypeCheckDeclOverride.cpp

@@ -242,18 +242,14 @@ bool swift::isOverrideBasedOnType(const ValueDecl *decl, Type declTy,
 
 static bool isUnavailableInAllVersions(ValueDecl *decl) {
   ASTContext &ctx = decl->getASTContext();
-  auto *attr = decl->getUnavailableAttr();
+  auto attr = decl->getUnavailableAttr();
   if (!attr)
     return false;
 
-  auto semanticAttr = decl->getSemanticAvailableAttr(attr);
-  if (!semanticAttr)
-    return false;
-
   if (attr->isUnconditionallyUnavailable())
     return true;
 
-  return semanticAttr->getVersionAvailability(ctx) ==
+  return attr->getVersionAvailability(ctx) ==
          AvailableVersionComparison::Unavailable;
 }
 
@@ -1942,11 +1938,12 @@ checkOverrideUnavailability(ValueDecl *override, ValueDecl *base) {
     }
   }
 
-  auto *baseUnavailableAttr = base->getUnavailableAttr();
-  auto *overrideUnavailableAttr = override->getUnavailableAttr();
+  auto baseUnavailableAttr = base->getUnavailableAttr();
+  auto overrideUnavailableAttr = override->getUnavailableAttr();
 
   if (baseUnavailableAttr && !overrideUnavailableAttr)
-    return {OverrideUnavailabilityStatus::BaseUnavailable, baseUnavailableAttr};
+    return {OverrideUnavailabilityStatus::BaseUnavailable,
+            baseUnavailableAttr->getParsedAttr()};
 
   return {OverrideUnavailabilityStatus::Compatible, nullptr};
 }