AST: Move several queries to SemanticAvailableAttr.

tshortli · tshortli · commit 111661e1d2cd · 2024-12-19T08:40:01.000-08:00
diff --git a/include/swift/AST/Attr.h b/include/swift/AST/Attr.h
@@ -783,12 +783,6 @@ class AvailableAttr : public DeclAttribute {
   /// Indicates where the Obsoleted version was specified.
   const SourceRange ObsoletedRange;
 
-  /// Whether this is a language-version-specific entity.
-  bool isLanguageVersionSpecific() const;
-
-  /// Whether this is a PackageDescription version specific entity.
-  bool isPackageDescriptionVersionSpecific() const;
-
   /// Whether this is an unconditionally unavailable entity.
   bool isUnconditionallyUnavailable() const;
 
@@ -832,17 +826,6 @@ class AvailableAttr : public DeclAttribute {
   /// Returns true if this attribute is active given the current platform.
   bool isActivePlatform(const ASTContext &ctx) const;
 
-  /// 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
-  /// version for PackageDescription version-specific availability.
-  llvm::VersionTuple getActiveVersion(const ASTContext &ctx) const;
-
-  /// Compare this attribute's version information against the platform or
-  /// language version (assuming the this attribute pertains to the active
-  /// platform).
-  AvailableVersionComparison getVersionAvailability(const ASTContext &ctx) const;
-
   /// Create an AvailableAttr that indicates specific availability
   /// for all platforms.
   static AvailableAttr *
@@ -3214,6 +3197,34 @@ class SemanticAvailableAttr final {
   /// `PlatformKind::none` if the attribute is not platform specific.
   PlatformKind getPlatformKind() const { return domain.getPlatformKind(); }
 
+  /// Whether this attribute has an introduced, deprecated, or obsoleted
+  /// version.
+  bool isVersionSpecific() const {
+    return attr->Introduced || attr->Deprecated || attr->Obsoleted;
+  }
+
+  /// Whether this is a language mode specific attribute.
+  bool isSwiftLanguageModeSpecific() const {
+    return domain.isSwiftLanguage() && isVersionSpecific();
+  }
+
+  /// Whether this is a PackageDescription version specific attribute.
+  bool isPackageDescriptionVersionSpecific() const {
+    return domain.isPackageDescription() && isVersionSpecific();
+  }
+
+  /// 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
+  /// version for PackageDescription version-specific availability.
+  llvm::VersionTuple getActiveVersion(const ASTContext &ctx) const;
+
+  /// Compare this attribute's version information against the platform or
+  /// language version (assuming the this attribute pertains to the active
+  /// platform).
+  AvailableVersionComparison
+  getVersionAvailability(const ASTContext &ctx) const;
+
   /// Returns true if this attribute is considered active in the current
   /// compilation context.
   bool isActive(ASTContext &ctx) const;
diff --git a/lib/AST/Attr.cpp b/lib/AST/Attr.cpp
@@ -830,11 +830,10 @@ void DeclAttributes::print(ASTPrinter &Printer, const PrintOptions &Options,
       if (!semanticAttr)
         continue;
 
-      auto domain = semanticAttr->getDomain();
       if (isShortAvailable(*semanticAttr)) {
-        if (domain.isSwiftLanguage())
+        if (semanticAttr->isSwiftLanguageModeSpecific())
           swiftVersionAvailableAttribute.emplace(*semanticAttr);
-        else if (domain.isPackageDescription())
+        else if (semanticAttr->isPackageDescriptionVersionSpecific())
           packageDescriptionVersionAvailableAttribute.emplace(*semanticAttr);
         else
           shortAvailableAttributes.push_back(*semanticAttr);
@@ -2169,32 +2168,6 @@ OriginallyDefinedInAttr *OriginallyDefinedInAttr::clone(ASTContext &C,
       OriginalModuleName, Platform, MovedVersion, implicit);
 }
 
-bool AvailableAttr::isLanguageVersionSpecific() const {
-  if (getPlatformAgnosticAvailability() ==
-      PlatformAgnosticAvailabilityKind::SwiftVersionSpecific)
-    {
-      assert(getPlatform() == PlatformKind::none &&
-             (Introduced.has_value() ||
-              Deprecated.has_value() ||
-              Obsoleted.has_value()));
-      return true;
-    }
-  return false;
-}
-
-bool AvailableAttr::isPackageDescriptionVersionSpecific() const {
-  if (getPlatformAgnosticAvailability() ==
-      PlatformAgnosticAvailabilityKind::PackageDescriptionVersionSpecific)
-    {
-      assert(getPlatform() == PlatformKind::none &&
-             (Introduced.has_value() ||
-              Deprecated.has_value() ||
-              Obsoleted.has_value()));
-      return true;
-    }
-  return false;
-}
-
 bool AvailableAttr::isUnconditionallyUnavailable() const {
   switch (getPlatformAgnosticAvailability()) {
   case PlatformAgnosticAvailabilityKind::None:
@@ -2234,8 +2207,9 @@ bool AvailableAttr::isNoAsync() const {
          PlatformAgnosticAvailabilityKind::NoAsync;
 }
 
-llvm::VersionTuple AvailableAttr::getActiveVersion(const ASTContext &ctx) const {
-  if (isLanguageVersionSpecific()) {
+llvm::VersionTuple
+SemanticAvailableAttr::getActiveVersion(const ASTContext &ctx) const {
+  if (isSwiftLanguageModeSpecific()) {
     return ctx.LangOpts.EffectiveLanguageVersion;
   } else if (isPackageDescriptionVersionSpecific()) {
     return ctx.LangOpts.PackageDescriptionVersion;
@@ -2244,32 +2218,32 @@ llvm::VersionTuple AvailableAttr::getActiveVersion(const ASTContext &ctx) const
   }
 }
 
-AvailableVersionComparison AvailableAttr::getVersionAvailability(
-  const ASTContext &ctx) const {
+AvailableVersionComparison
+SemanticAvailableAttr::getVersionAvailability(const ASTContext &ctx) const {
 
   // Unconditional unavailability.
-  if (isUnconditionallyUnavailable())
+  if (attr->isUnconditionallyUnavailable())
     return AvailableVersionComparison::Unavailable;
 
   llvm::VersionTuple queryVersion = getActiveVersion(ctx);
-  std::optional<llvm::VersionTuple> ObsoletedVersion = Obsoleted;
+  std::optional<llvm::VersionTuple> ObsoletedVersion = attr->Obsoleted;
 
-  StringRef ObsoletedPlatform = prettyPlatformString();
+  StringRef ObsoletedPlatform;
   llvm::VersionTuple RemappedObsoletedVersion;
   if (AvailabilityInference::updateObsoletedPlatformForFallback(
-      this, ctx, ObsoletedPlatform, RemappedObsoletedVersion))
+          attr, ctx, ObsoletedPlatform, RemappedObsoletedVersion))
     ObsoletedVersion = RemappedObsoletedVersion;
 
   // If this entity was obsoleted before or at the query platform version,
   // consider it obsolete.
   if (ObsoletedVersion && *ObsoletedVersion <= queryVersion)
     return AvailableVersionComparison::Obsoleted;
 
-  std::optional<llvm::VersionTuple> IntroducedVersion = Introduced;
-  StringRef IntroducedPlatform = prettyPlatformString();
+  std::optional<llvm::VersionTuple> IntroducedVersion = attr->Introduced;
+  StringRef IntroducedPlatform;
   llvm::VersionTuple RemappedIntroducedVersion;
   if (AvailabilityInference::updateIntroducedPlatformForFallback(
-      this, ctx, IntroducedPlatform, RemappedIntroducedVersion))
+          attr, ctx, IntroducedPlatform, RemappedIntroducedVersion))
     IntroducedVersion = RemappedIntroducedVersion;
 
   // If this entity was introduced after the query version and we're doing a
@@ -2278,7 +2252,7 @@ AvailableVersionComparison AvailableAttr::getVersionAvailability(
   // static requirement, so we treat "introduced later" as just plain
   // unavailable.
   if (IntroducedVersion && *IntroducedVersion > queryVersion) {
-    if (isLanguageVersionSpecific() || isPackageDescriptionVersionSpecific())
+    if (isSwiftLanguageModeSpecific() || isPackageDescriptionVersionSpecific())
       return AvailableVersionComparison::Unavailable;
     else
       return AvailableVersionComparison::PotentiallyUnavailable;
diff --git a/lib/AST/Availability.cpp b/lib/AST/Availability.cpp
@@ -537,7 +537,7 @@ const AvailableAttr *Decl::getDeprecatedAttr() const {
 
     std::optional<llvm::VersionTuple> deprecatedVersion = attr->Deprecated;
 
-    StringRef deprecatedPlatform = attr->prettyPlatformString();
+    StringRef deprecatedPlatform;
     llvm::VersionTuple remappedDeprecatedVersion;
     if (AvailabilityInference::updateDeprecatedPlatformForFallback(
             attr, ctx, deprecatedPlatform, remappedDeprecatedVersion))
@@ -546,7 +546,7 @@ const AvailableAttr *Decl::getDeprecatedAttr() const {
     if (!deprecatedVersion.has_value())
       continue;
 
-    llvm::VersionTuple minVersion = attr->getActiveVersion(ctx);
+    llvm::VersionTuple minVersion = semanticAttr.getActiveVersion(ctx);
 
     // We treat the declaration as deprecated if it is deprecated on
     // all deployment targets.
@@ -573,7 +573,7 @@ const AvailableAttr *Decl::getSoftDeprecatedAttr() const {
     if (!deprecatedVersion.has_value())
       continue;
 
-    llvm::VersionTuple activeVersion = attr->getActiveVersion(ctx);
+    llvm::VersionTuple activeVersion = semanticAttr.getActiveVersion(ctx);
 
     if (deprecatedVersion.value() > activeVersion)
       result = attr;
@@ -618,10 +618,8 @@ bool Decl::isUnavailableInCurrentSwiftVersion() const {
   llvm::VersionTuple vers = getASTContext().LangOpts.EffectiveLanguageVersion;
   for (auto semanticAttr :
        getSemanticAvailableAttrs(/*includingInactive=*/false)) {
-    auto attr = semanticAttr.getParsedAttr();
-    auto domain = semanticAttr.getDomain();
-
-    if (domain.isSwiftLanguage()) {
+    if (semanticAttr.isSwiftLanguageModeSpecific()) {
+      auto attr = semanticAttr.getParsedAttr();
       if (attr->Introduced.has_value() && attr->Introduced.value() > vers)
         return true;
       if (attr->Obsoleted.has_value() && attr->Obsoleted.value() <= vers)
@@ -656,7 +654,7 @@ getDeclUnavailableAttr(const Decl *D, bool ignoreAppExtensions) {
     if (attr->isUnconditionallyUnavailable())
       return attr;
 
-    switch (attr->getVersionAvailability(ctx)) {
+    switch (semanticAttr.getVersionAvailability(ctx)) {
     case AvailableVersionComparison::Available:
     case AvailableVersionComparison::PotentiallyUnavailable:
       break;
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -2171,10 +2171,12 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
   if (SF && SF->Kind == SourceFileKind::Interface)
     return;
 
-  // The remaining diagnostics are only for attributes that are active for the
-  // current target triple.
-  if (!attr->isActivePlatform(Ctx) && !attr->isLanguageVersionSpecific() &&
-      !attr->isPackageDescriptionVersionSpecific())
+  // The remaining diagnostics are only for attributes that are active.
+  auto semanticAttr = D->getSemanticAvailableAttr(attr);
+  if (!semanticAttr)
+    return;
+
+  if (!semanticAttr->isActive(Ctx))
     return;
 
   // Make sure there isn't a more specific attribute we should be using instead.
@@ -2195,7 +2197,7 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
   }
 
   SourceLoc attrLoc = attr->getLocation();
-  auto versionAvailability = attr->getVersionAvailability(Ctx);
+  auto versionAvailability = semanticAttr->getVersionAvailability(Ctx);
   if (versionAvailability == AvailableVersionComparison::Obsoleted ||
       versionAvailability == AvailableVersionComparison::Unavailable) {
     if (auto cannotBeUnavailable =
diff --git a/lib/Sema/TypeCheckAvailability.cpp b/lib/Sema/TypeCheckAvailability.cpp
@@ -3067,14 +3067,14 @@ getExplicitUnavailabilityDiagnosticInfo(const Decl *decl,
 
   ASTContext &ctx = decl->getASTContext();
 
-  switch (attr->getVersionAvailability(ctx)) {
+  switch (semanticAttr->getVersionAvailability(ctx)) {
   case AvailableVersionComparison::Available:
   case AvailableVersionComparison::PotentiallyUnavailable:
     llvm_unreachable("These aren't considered unavailable");
 
   case AvailableVersionComparison::Unavailable:
-    if ((attr->isLanguageVersionSpecific() ||
-         attr->isPackageDescriptionVersionSpecific()) &&
+    if ((semanticAttr->isSwiftLanguageModeSpecific() ||
+         semanticAttr->isPackageDescriptionVersionSpecific()) &&
         attr->Introduced.has_value()) {
       return UnavailabilityDiagnosticInfo(
           UnavailabilityDiagnosticInfo::Status::IntroducedInVersion, attr,
@@ -3161,18 +3161,22 @@ 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))
       return std::nullopt;
 
-    switch (attr->getVersionAvailability(ctx)) {
+    switch (semanticAttr->getVersionAvailability(ctx)) {
     case AvailableVersionComparison::Available:
     case AvailableVersionComparison::PotentiallyUnavailable:
       llvm_unreachable("Decl should be unavailable");
 
     case AvailableVersionComparison::Unavailable:
-      if ((attr->isLanguageVersionSpecific() ||
-           attr->isPackageDescriptionVersionSpecific()) &&
+      if ((semanticAttr->isSwiftLanguageModeSpecific() ||
+           semanticAttr->isPackageDescriptionVersionSpecific()) &&
           attr->Introduced.has_value())
         return AvailabilityConstraint::forRequiresVersion(attr);
 
diff --git a/lib/Sema/TypeCheckDeclOverride.cpp b/lib/Sema/TypeCheckDeclOverride.cpp
@@ -243,14 +243,18 @@ bool swift::isOverrideBasedOnType(const ValueDecl *decl, Type declTy,
 static bool isUnavailableInAllVersions(ValueDecl *decl) {
   ASTContext &ctx = decl->getASTContext();
   auto *attr = decl->getUnavailableAttr();
-
   if (!attr)
     return false;
+
+  auto semanticAttr = decl->getSemanticAvailableAttr(attr);
+  if (!semanticAttr)
+    return false;
+
   if (attr->isUnconditionallyUnavailable())
     return true;
 
-  return attr->getVersionAvailability(ctx)
-             == AvailableVersionComparison::Unavailable;
+  return semanticAttr->getVersionAvailability(ctx) ==
+         AvailableVersionComparison::Unavailable;
 }
 
 /// Perform basic checking to determine whether a declaration can override a
diff --git a/lib/Sema/TypeCheckDeclPrimary.cpp b/lib/Sema/TypeCheckDeclPrimary.cpp
@@ -916,13 +916,11 @@ CheckRedeclarationRequest::evaluate(Evaluator &eval, ValueDecl *current,
           static AvailabilityRange from(const ValueDecl *VD) {
             AvailabilityRange result;
             for (auto semanticAttr : VD->getSemanticAvailableAttrs()) {
-              auto attr = semanticAttr.getParsedAttr();
-              auto domain = semanticAttr.getDomain();
-              if (domain.isSwiftLanguage()) {
-                if (attr->Introduced)
-                  result.introduced = attr->Introduced;
-                if (attr->Obsoleted)
-                  result.obsoleted = attr->Obsoleted;
+              if (semanticAttr.isSwiftLanguageModeSpecific()) {
+                if (auto introduced = semanticAttr.getParsedAttr()->Introduced)
+                  result.introduced = introduced;
+                if (auto obsoleted = semanticAttr.getParsedAttr()->Obsoleted)
+                  result.obsoleted = obsoleted;
               }
             }
             return result;
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
@@ -3044,6 +3044,10 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
 
       assert(theAttr->Rename.empty() || !theAttr->hasCachedRenamedDecl());
 
+      bool isPackageDescriptionVersionSpecific =
+          theAttr->getPlatformAgnosticAvailability() ==
+          PlatformAgnosticAvailabilityKind::PackageDescriptionVersionSpecific;
+
       llvm::SmallString<32> blob;
       blob.append(theAttr->Message);
       blob.append(theAttr->Rename);
@@ -3054,7 +3058,7 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
           theAttr->isUnconditionallyUnavailable(),
           theAttr->isUnconditionallyDeprecated(),
           theAttr->isNoAsync(),
-          theAttr->isPackageDescriptionVersionSpecific(),
+          isPackageDescriptionVersionSpecific,
           theAttr->isSPI(),
           theAttr->isForEmbedded(),
           LIST_VER_TUPLE_PIECES(Introduced),
