AST: Return a SemanticAvailableAttr from Decl::getDeprecatedAttr().

Author: tshortli

include/swift/AST/Attr.h

@@ -3215,6 +3215,16 @@ class SemanticAvailableAttr final {
   /// `PlatformKind::none` if the attribute is not platform specific.
   PlatformKind getPlatform() const { return getDomain().getPlatformKind(); }
 
+  /// Whether this is attribute indicates unavailability in all versions.
+  bool isUnconditionallyUnavailable() const {
+    return attr->isUnconditionallyUnavailable();
+  }
+
+  /// Whether this is attribute indicates deprecation in all versions.
+  bool isUnconditionallyDeprecated() const {
+    return attr->isUnconditionallyDeprecated();
+  }
+
   /// Whether this is a `noasync` attribute.
   bool isNoAsync() const { return attr->isNoAsync(); }
 

include/swift/AST/Decl.h

@@ -1416,15 +1416,15 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
 
   /// Returns true if the declaration is deprecated at the current deployment
   /// target.
-  bool isDeprecated() const { return getDeprecatedAttr() != nullptr; }
+  bool isDeprecated() const { return getDeprecatedAttr().has_value(); }
 
   /// Returns the first `@available` attribute that indicates that this decl
   /// is deprecated on current deployment target, or `nullptr` otherwise.
-  const AvailableAttr *getDeprecatedAttr() const;
+  std::optional<SemanticAvailableAttr> getDeprecatedAttr() const;
 
   /// Returns the first `@available` attribute that indicates that this decl
   /// will be deprecated in the future, or `nullptr` otherwise.
-  const AvailableAttr *getSoftDeprecatedAttr() const;
+  std::optional<SemanticAvailableAttr> getSoftDeprecatedAttr() const;
 
   /// Returns the first @available attribute that indicates this decl is
   /// unavailable from asynchronous contexts, or `nullptr` otherwise.

lib/AST/Availability.cpp

@@ -511,64 +511,60 @@ Decl::getActiveAvailableAttrForCurrentPlatform(bool ignoreAppExtensions) const {
   return bestAttr;
 }
 
-const AvailableAttr *Decl::getDeprecatedAttr() const {
+std::optional<SemanticAvailableAttr> Decl::getDeprecatedAttr() const {
   auto &ctx = getASTContext();
-  const AvailableAttr *result = nullptr;
+  std::optional<SemanticAvailableAttr> result;
   auto bestActive = getActiveAvailableAttrForCurrentPlatform();
 
-  for (auto semanticAttr :
-       getSemanticAvailableAttrs(/*includingInactive=*/false)) {
-    auto attr = semanticAttr.getParsedAttr();
-
-    if (attr->hasPlatform() && (!bestActive || semanticAttr != bestActive))
+  for (auto attr : getSemanticAvailableAttrs(/*includingInactive=*/false)) {
+    if (attr.isPlatformSpecific() && (!bestActive || attr != bestActive))
       continue;
 
     // Unconditional deprecated.
-    if (attr->isUnconditionallyDeprecated())
+    if (attr.isUnconditionallyDeprecated())
       return attr;
 
-    std::optional<llvm::VersionTuple> deprecatedVersion = attr->Deprecated;
+    auto deprecatedVersion = attr.getDeprecated();
 
     StringRef deprecatedPlatform;
     llvm::VersionTuple remappedDeprecatedVersion;
     if (AvailabilityInference::updateDeprecatedPlatformForFallback(
-            attr, ctx, deprecatedPlatform, remappedDeprecatedVersion))
+            attr.getParsedAttr(), ctx, deprecatedPlatform,
+            remappedDeprecatedVersion))
       deprecatedVersion = remappedDeprecatedVersion;
 
     if (!deprecatedVersion.has_value())
       continue;
 
-    llvm::VersionTuple minVersion = semanticAttr.getActiveVersion(ctx);
+    llvm::VersionTuple minVersion = attr.getActiveVersion(ctx);
 
     // We treat the declaration as deprecated if it is deprecated on
     // all deployment targets.
     if (deprecatedVersion.value() <= minVersion) {
-      result = attr;
+      result.emplace(attr);
     }
   }
   return result;
 }
 
-const AvailableAttr *Decl::getSoftDeprecatedAttr() const {
+std::optional<SemanticAvailableAttr> Decl::getSoftDeprecatedAttr() const {
   auto &ctx = getASTContext();
-  const AvailableAttr *result = nullptr;
+  std::optional<SemanticAvailableAttr> result;
   auto bestActive = getActiveAvailableAttrForCurrentPlatform();
 
-  for (auto semanticAttr :
-       getSemanticAvailableAttrs(/*includingInactive=*/false)) {
-    auto attr = semanticAttr.getParsedAttr();
-
-    if (attr->hasPlatform() && (!bestActive || semanticAttr != bestActive))
+  for (auto attr : getSemanticAvailableAttrs(/*includingInactive=*/false)) {
+    if (attr.isPlatformSpecific() && (!bestActive || attr != bestActive))
       continue;
 
-    std::optional<llvm::VersionTuple> deprecatedVersion = attr->Deprecated;
+    // FIXME: This needs to do a version remap.
+    auto deprecatedVersion = attr.getDeprecated();
     if (!deprecatedVersion.has_value())
       continue;
 
-    llvm::VersionTuple activeVersion = semanticAttr.getActiveVersion(ctx);
+    llvm::VersionTuple activeVersion = attr.getActiveVersion(ctx);
 
     if (deprecatedVersion.value() > activeVersion)
-      result = attr;
+      result.emplace(attr);
   }
   return result;
 }

lib/IDE/CodeCompletionDiagnostics.cpp

@@ -55,6 +55,11 @@ class CodeCompletionDiagnostics {
                  llvm::raw_ostream &Out, Diag<ArgTypes...> ID,
                  typename swift::detail::PassArgument<ArgTypes>::type... VArgs);
 
+  bool getDiagnosticForDeprecated(const ValueDecl *D, const AvailableAttr *Attr,
+                                  bool isSoftDeprecated,
+                                  CodeCompletionDiagnosticSeverity &severity,
+                                  llvm::raw_ostream &Out);
+
   bool getDiagnosticForDeprecated(const ValueDecl *D,
                                   CodeCompletionDiagnosticSeverity &severity,
                                   llvm::raw_ostream &Out);
@@ -75,16 +80,9 @@ bool CodeCompletionDiagnostics::getDiagnostics(
 }
 
 bool CodeCompletionDiagnostics::getDiagnosticForDeprecated(
-    const ValueDecl *D, CodeCompletionDiagnosticSeverity &severity,
-    llvm::raw_ostream &Out) {
-  bool isSoftDeprecated = false;
-  const AvailableAttr *Attr = D->getDeprecatedAttr();
-  if (!Attr) {
-    Attr = D->getSoftDeprecatedAttr();
-    isSoftDeprecated = true;
-  }
-  if (!Attr)
-    return true;
+    const ValueDecl *D, const AvailableAttr *Attr, bool isSoftDeprecated,
+    CodeCompletionDiagnosticSeverity &severity, llvm::raw_ostream &Out) {
+  assert(Attr);
 
   // FIXME: Code completion doesn't offer accessors. It only emits 'VarDecl's.
   // So getter/setter specific availability doesn't work in code completion.
@@ -144,6 +142,20 @@ bool CodeCompletionDiagnostics::getDiagnosticForDeprecated(
   return false;;
 }
 
+bool CodeCompletionDiagnostics::getDiagnosticForDeprecated(
+    const ValueDecl *D, CodeCompletionDiagnosticSeverity &severity,
+    llvm::raw_ostream &Out) {
+  if (auto attr = D->getDeprecatedAttr())
+    return getDiagnosticForDeprecated(D, attr->getParsedAttr(), false, severity,
+                                      Out);
+
+  if (auto attr = D->getSoftDeprecatedAttr())
+    return getDiagnosticForDeprecated(D, attr->getParsedAttr(), true, severity,
+                                      Out);
+
+  return true;
+}
+
 } // namespace
 
 bool swift::ide::getContextFreeCompletionDiagnostics(

lib/Sema/TypeCheckAvailability.cpp

@@ -2373,14 +2373,14 @@ diagnosePotentialUnavailability(const RootProtocolConformance *rootConf,
 /// declaration is deprecated or null otherwise.
 static const AvailableAttr *getDeprecated(const Decl *D) {
   auto &Ctx = D->getASTContext();
-  if (auto *Attr = D->getDeprecatedAttr())
-    return Attr;
+  if (auto Attr = D->getDeprecatedAttr())
+    return Attr->getParsedAttr();
 
   if (Ctx.LangOpts.WarnSoftDeprecated) {
     // When -warn-soft-deprecated is specified, treat any declaration that is
     // deprecated in the future as deprecated.
-    if (auto *Attr = D->getSoftDeprecatedAttr())
-      return Attr;
+    if (auto Attr = D->getSoftDeprecatedAttr())
+      return Attr->getParsedAttr();
   }
 
   // Treat extensions methods as deprecated if their extension

lib/Sema/TypeCheckProtocol.cpp

@@ -4452,8 +4452,8 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
             auto &ctx = witness->getASTContext();
             auto &diags = ctx.Diags;
             SourceLoc diagLoc = getLocForDiagnosingWitness(conformance, witness);
-            auto *attr = witness->getDeprecatedAttr();
-            EncodedDiagnosticMessage EncodedMessage(attr->Message);
+            auto attr = witness->getDeprecatedAttr();
+            EncodedDiagnosticMessage EncodedMessage(attr->getMessage());
             diags.diagnose(diagLoc, diag::witness_deprecated,
                            witness, conformance->getProtocol()->getName(),
                            EncodedMessage.Message);