Merge pull request #83168 from tshortli/custom-availability-domain-fix-its

AST/Sema: Generalize availability fix-its to support custom availability domains

Author: tshortli

include/swift/AST/AvailabilityConstraint.h

@@ -188,12 +188,21 @@ enum class AvailabilityConstraintFlag : uint8_t {
 };
 using AvailabilityConstraintFlags = OptionSet<AvailabilityConstraintFlag>;
 
-/// Returns the set of availability constraints that restrict use of \p decl
+/// Returns the set of availability constraints that restricts use of \p decl
 /// when it is referenced from the given context. In other words, it is the
-/// collection of of `@available` attributes with unsatisfied conditions.
+/// collection of `@available` attributes with unsatisfied conditions.
 DeclAvailabilityConstraints getAvailabilityConstraintsForDecl(
     const Decl *decl, const AvailabilityContext &context,
     AvailabilityConstraintFlags flags = std::nullopt);
+
+/// Returns the availability constraints that restricts use of \p decl
+/// in \p domain when it is referenced from the given context. In other words,
+/// it is the unsatisfied `@available` attribute  that applies to \p domain in
+/// the given context.
+std::optional<AvailabilityConstraint> getAvailabilityConstraintForDeclInDomain(
+    const Decl *decl, const AvailabilityContext &context,
+    AvailabilityDomain domain,
+    AvailabilityConstraintFlags flags = std::nullopt);
 } // end namespace swift
 
 namespace llvm {

include/swift/AST/AvailabilityDomain.h

@@ -260,6 +260,12 @@ class AvailabilityDomain final {
   /// universal domain (`*`) is the bottom element.
   bool contains(const AvailabilityDomain &other) const;
 
+  /// Returns true if availability in `other` is a subset of availability in
+  /// this domain or vice-versa.
+  bool isRelated(const AvailabilityDomain &other) const {
+    return contains(other) || other.contains(*this);
+  }
+
   /// Returns true for domains that are not contained by any domain other than
   /// the universal domain.
   bool isRoot() const;

include/swift/AST/AvailabilityScope.h

@@ -272,8 +272,11 @@ class AvailabilityScope : public ASTAllocated<AvailabilityScope> {
       AvailabilityDomain Domain, const llvm::VersionTuple &Version) const;
 
   /// Returns the availability version range that was explicitly written in
-  /// source, if applicable. Otherwise, returns null.
-  std::optional<const AvailabilityRange> getExplicitAvailabilityRange() const;
+  /// source for the given domain, if applicable. Otherwise, returns
+  /// `std::nullopt`.
+  std::optional<const AvailabilityRange>
+  getExplicitAvailabilityRange(AvailabilityDomain Domain,
+                               ASTContext &Ctx) const;
 
   /// Returns the source range this scope represents.
   SourceRange getSourceRange() const { return SrcRange; }

include/swift/AST/Decl.h

@@ -1464,6 +1464,27 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   std::optional<SemanticAvailableAttr>
   getAvailableAttrForPlatformIntroduction(bool checkExtension = true) const;
 
+  /// Returns true if `decl` has any active `@available` attribute attached to
+  /// it.
+  bool hasAnyActiveAvailableAttr() const {
+    return hasAnyMatchingActiveAvailableAttr(
+        [](SemanticAvailableAttr attr) -> bool { return true; });
+  }
+
+  /// Returns true if `predicate` returns true for any active availability
+  /// attribute attached to `decl`. The predicate function should accept a
+  /// `SemanticAvailableAttr`.
+  template <typename F>
+  bool hasAnyMatchingActiveAvailableAttr(F predicate) const {
+    auto &ctx = getASTContext();
+    auto decl = getAbstractSyntaxDeclForAttributes();
+    for (auto attr : decl->getSemanticAvailableAttrs()) {
+      if (attr.isActive(ctx) && predicate(attr))
+        return true;
+    }
+    return false;
+  }
+
   /// Returns true if the declaration is deprecated at the current deployment
   /// target.
   bool isDeprecated() const { return getDeprecatedAttr().has_value(); }

include/swift/AST/DiagnosticsSema.def

@@ -7070,9 +7070,6 @@ NOTE(availability_guard_with_version_check, none,
 
 NOTE(availability_add_attribute, none,
      "add '@available' attribute to enclosing %kindonly0", (const Decl *))
-FIXIT(insert_available_attr,
-      "@available(%0 %1, *)\n%2",
-      (StringRef, StringRef, StringRef))
 
 ERROR(availability_inout_accessor_only_in, none,
       "cannot pass as inout because %0 is only available in %1"

lib/AST/AvailabilityConstraint.cpp

@@ -331,3 +331,15 @@ swift::getAvailabilityConstraintsForDecl(const Decl *decl,
   return constraints;
 }
 
+std::optional<AvailabilityConstraint>
+swift::getAvailabilityConstraintForDeclInDomain(
+    const Decl *decl, const AvailabilityContext &context,
+    AvailabilityDomain domain, AvailabilityConstraintFlags flags) {
+  auto constraints = getAvailabilityConstraintsForDecl(decl, context, flags);
+  for (auto const &constraint : constraints) {
+    if (constraint.getDomain().isRelated(domain))
+      return constraint;
+  }
+
+  return std::nullopt;
+}

lib/AST/AvailabilityScope.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/AvailabilityScope.h"
 
 #include "swift/AST/ASTContext.h"
+#include "swift/AST/AvailabilityConstraint.h"
 #include "swift/AST/AvailabilityInference.h"
 #include "swift/AST/AvailabilitySpec.h"
 #include "swift/AST/Decl.h"
@@ -356,15 +357,17 @@ SourceRange AvailabilityScope::getAvailabilityConditionVersionSourceRange(
 }
 
 std::optional<const AvailabilityRange>
-AvailabilityScope::getExplicitAvailabilityRange() const {
+AvailabilityScope::getExplicitAvailabilityRange(AvailabilityDomain domain,
+                                                ASTContext &ctx) const {
   switch (getReason()) {
   case Reason::Root:
     return std::nullopt;
 
   case Reason::Decl: {
     auto decl = Node.getAsDecl();
-    if (auto attr = decl->getAvailableAttrForPlatformIntroduction())
-      return attr->getIntroducedRange(decl->getASTContext());
+    if (auto constraint = swift::getAvailabilityConstraintForDeclInDomain(
+            decl, AvailabilityContext::forAlwaysAvailable(ctx), domain))
+      return constraint->getAttr().getIntroducedRange(ctx);
 
     return std::nullopt;
   }
@@ -379,22 +382,12 @@ AvailabilityScope::getExplicitAvailabilityRange() const {
   case Reason::GuardStmtElseBranch:
   case Reason::WhileStmtBody:
     // Availability is inherently explicit for all of these nodes.
-    return getPlatformAvailabilityRange();
+    return getAvailabilityContext().getAvailabilityRange(domain, ctx);
   }
 
   llvm_unreachable("Unhandled Reason in switch.");
 }
 
-static std::string
-stringForAvailability(const AvailabilityRange &availability) {
-  if (availability.isAlwaysAvailable())
-    return "all";
-  if (availability.isKnownUnreachable())
-    return "none";
-
-  return availability.getVersionString();
-}
-
 void AvailabilityScope::print(raw_ostream &OS, SourceManager &SrcMgr,
                               unsigned Indent) const {
   OS.indent(Indent);
@@ -446,9 +439,6 @@ void AvailabilityScope::print(raw_ostream &OS, SourceManager &SrcMgr,
     }
   }
 
-  if (auto explicitAvailability = getExplicitAvailabilityRange())
-    OS << " explicit_version=" << stringForAvailability(*explicitAvailability);
-
   for (AvailabilityScope *Child : Children) {
     OS << '\n';
     Child->print(OS, SrcMgr, Indent + 2);

lib/AST/AvailabilityScopeBuilder.cpp

@@ -30,20 +30,6 @@
 
 using namespace swift;
 
-/// Returns true if there is any availability attribute on the declaration
-/// that is active.
-// FIXME: [availability] De-duplicate this with TypeCheckAvailability.cpp.
-static bool hasActiveAvailableAttribute(const Decl *decl, ASTContext &ctx) {
-  decl = decl->getAbstractSyntaxDeclForAttributes();
-
-  for (auto attr : decl->getSemanticAvailableAttrs()) {
-    if (attr.isActive(ctx))
-      return true;
-  }
-
-  return false;
-}
-
 static bool computeContainedByDeploymentTarget(AvailabilityScope *scope,
                                                ASTContext &ctx) {
   return scope->getPlatformAvailabilityRange().isContainedIn(
@@ -397,7 +383,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
       return nullptr;
 
     // Declarations with explicit availability attributes always get a scope.
-    if (hasActiveAvailableAttribute(decl, Context)) {
+    if (decl->hasAnyActiveAvailableAttr()) {
       return AvailabilityScope::createForDecl(
           Context, decl, getCurrentScope(),
           getEffectiveAvailabilityForDeclSignature(decl),
@@ -423,16 +409,20 @@ class AvailabilityScopeBuilder : private ASTWalker {
   getEffectiveAvailabilityForDeclSignature(const Decl *decl) {
     auto effectiveIntroduction = AvailabilityRange::alwaysAvailable();
 
-    // Availability attributes are found abstract syntax decls.
+    // Availability attributes are found on abstract syntax decls.
     decl = decl->getAbstractSyntaxDeclForAttributes();
 
     // As a special case, extension decls are treated as effectively as
     // available as the nominal type they extend, up to the deployment target.
     // This rule is a convenience for library authors who have written
-    // extensions without specifying availabilty on the extension itself.
+    // extensions without specifying platform availabilty on the extension
+    // itself.
     if (auto *extension = dyn_cast<ExtensionDecl>(decl)) {
       auto extendedType = extension->getExtendedType();
-      if (extendedType && !hasActiveAvailableAttribute(decl, Context)) {
+      if (extendedType && !decl->hasAnyMatchingActiveAvailableAttr(
+                              [](SemanticAvailableAttr attr) -> bool {
+                                return attr.getDomain().isPlatform();
+                              })) {
         effectiveIntroduction.intersectWith(
             swift::AvailabilityInference::inferForType(extendedType));
 
@@ -1087,9 +1077,9 @@ class AvailabilityScopeBuilder : private ASTWalker {
         // current scope is completely contained in the range for the spec, then
         // a version query can never be false, so the spec is useless.
         // If so, report this.
-        // FIXME: [availability] Diagnose non-platform queries as useless too.
-        auto explicitRange = currentScope->getExplicitAvailabilityRange();
-        if (domain.isPlatform() && explicitRange && trueRange &&
+        auto explicitRange =
+            currentScope->getExplicitAvailabilityRange(domain, Context);
+        if (explicitRange && trueRange &&
             explicitRange->isContainedIn(*trueRange)) {
           // Platform unavailability queries never refine availability so don't
           // diangose them.
@@ -1098,17 +1088,9 @@ class AvailabilityScopeBuilder : private ASTWalker {
 
           DiagnosticEngine &diags = Context.Diags;
           if (currentScope->getReason() != AvailabilityScope::Reason::Root) {
-            PlatformKind bestPlatform = targetPlatform(Context.LangOpts);
-
-            // If possible, try to report the diagnostic in terms for the
-            // platform the user uttered in the '#available()'. For a platform
-            // that inherits availability from another platform it may be
-            // different from the platform specified in the target triple.
-            if (domain.getPlatformKind() != PlatformKind::none)
-              bestPlatform = domain.getPlatformKind();
             diags.diagnose(query->getLoc(),
                            diag::availability_query_useless_enclosing_scope,
-                           platformString(bestPlatform));
+                           domain.getNameForAttributePrinting());
             diags.diagnose(
                 currentScope->getIntroductionLoc(),
                 diag::availability_query_useless_enclosing_scope_here);

lib/Sema/TypeCheckAttr.cpp

@@ -2200,13 +2200,19 @@ static Decl *getEnclosingDeclForDecl(Decl *D) {
 }
 
 static std::optional<std::pair<SemanticAvailableAttr, const Decl *>>
-getSemanticAvailableRangeDeclAndAttr(const Decl *decl) {
-  if (auto attr = decl->getAvailableAttrForPlatformIntroduction(
-          /*checkExtension=*/false))
-    return std::make_pair(*attr, decl);
+getSemanticAvailableRangeDeclAndAttr(const Decl *decl,
+                                     AvailabilityDomain domain) {
+  auto &ctx = decl->getASTContext();
+  AvailabilityConstraintFlags flags =
+      AvailabilityConstraintFlag::SkipEnclosingExtension;
+  if (auto constraint = swift::getAvailabilityConstraintForDeclInDomain(
+          decl, AvailabilityContext::forAlwaysAvailable(ctx), domain, flags)) {
+    if (constraint->isPotentiallyAvailable())
+      return std::make_pair(constraint->getAttr(), decl);
+  }
 
   if (auto *parent = decl->parentDeclForAvailability())
-    return getSemanticAvailableRangeDeclAndAttr(parent);
+    return getSemanticAvailableRangeDeclAndAttr(parent, domain);
 
   return std::nullopt;
 }
@@ -2300,7 +2306,7 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *parsedAttr) {
 
   if (auto *parent = getEnclosingDeclForDecl(D)) {
     if (auto enclosingAvailable =
-            getSemanticAvailableRangeDeclAndAttr(parent)) {
+            getSemanticAvailableRangeDeclAndAttr(parent, attr->getDomain())) {
       SemanticAvailableAttr enclosingAttr = enclosingAvailable->first;
       const Decl *enclosingDecl = enclosingAvailable->second;
       enclosingIntroducedRange = enclosingAttr.getIntroducedRange(Ctx);
@@ -5245,8 +5251,8 @@ void AttributeChecker::checkBackDeployedAttrs(
     // If it's not, the attribute doesn't make sense since the back deployment
     // fallback could never be executed at runtime.
     if (auto availableRangeAttrPair =
-            getSemanticAvailableRangeDeclAndAttr(VD)) {
-      auto beforeDomain = Attr->getAvailabilityDomain();
+            getSemanticAvailableRangeDeclAndAttr(VD, Domain)) {
+      auto beforeDomain = Domain;
       auto beforeVersion = Attr->getVersion();
       auto availableAttr = availableRangeAttrPair.value().first;
       auto introVersion = availableAttr.getIntroduced().value();