Merge pull request #77362 from tshortli/replace-check-declaration-availability

Sema: Introduce `getUnmetAvailabilityRequirement()`

Author: tshortli

include/swift/AST/Availability.h

@@ -335,6 +335,78 @@ class AvailabilityRange {
   }
 };
 
+/// Represents the reason a declaration is considered unavailable in a certain
+/// context.
+class UnmetAvailabilityRequirement {
+public:
+  enum class Kind {
+    /// The declaration is referenced in a context in which it is
+    /// generally unavailable. For example, a reference to a declaration that is
+    /// unavailable on macOS from a context that may execute on macOS has this
+    /// unmet requirement.
+    AlwaysUnavailable,
+
+    /// The declaration is referenced in a context in which it is considered
+    /// obsolete. For example, a reference to a declaration that is obsolete in
+    /// macOS 13 from a context that may execute on macOS 13 or later has this
+    /// unmet requirement.
+    Obsoleted,
+
+    /// The declaration is only available in a different version. For example,
+    /// the declaration might only be introduced in the Swift 6 language mode
+    /// while the module is being compiled in the Swift 5 language mode.
+    RequiresVersion,
+
+    /// The declaration is referenced in a context that does not have an
+    /// adequate minimum version constraint. For example, a reference to a
+    /// declaration that is introduced in macOS 13 from a context that may
+    /// execute on earlier versions of macOS has this unmet requirement. This
+    /// kind of unmet requirement can be addressed by tightening the minimum
+    /// version of the context with `if #available(...)` or by adding or
+    /// adjusting an `@available` attribute.
+    IntroducedInNewerVersion,
+  };
+
+private:
+  Kind kind;
+  const AvailableAttr *attr;
+
+  UnmetAvailabilityRequirement(Kind kind, const AvailableAttr *attr)
+      : kind(kind), attr(attr){};
+
+public:
+  static UnmetAvailabilityRequirement
+  forAlwaysUnavailable(const AvailableAttr *attr) {
+    return UnmetAvailabilityRequirement(Kind::AlwaysUnavailable, attr);
+  }
+
+  static UnmetAvailabilityRequirement forObsoleted(const AvailableAttr *attr) {
+    return UnmetAvailabilityRequirement(Kind::Obsoleted, attr);
+  }
+
+  static UnmetAvailabilityRequirement
+  forRequiresVersion(const AvailableAttr *attr) {
+    return UnmetAvailabilityRequirement(Kind::RequiresVersion, attr);
+  }
+
+  static UnmetAvailabilityRequirement
+  forIntroducedInNewerVersion(const AvailableAttr *attr) {
+    return UnmetAvailabilityRequirement(Kind::IntroducedInNewerVersion, attr);
+  }
+
+  Kind getKind() const { return kind; }
+  const AvailableAttr *getAttr() const { return attr; }
+
+  /// Returns the required range for `IntroducedInNewerVersion` requirements, or
+  /// `std::nullopt` otherwise.
+  std::optional<AvailabilityRange>
+  getRequiredNewerAvailabilityRange(ASTContext &ctx) const;
+
+  /// Returns true if this unmet requirement can be satisfied by introducing an
+  /// `if #available(...)` condition in source.
+  bool isConditionallySatisfiable() const;
+};
+
 class AvailabilityInference {
 public:
   /// Returns the decl that should be considered the parent decl of the given

lib/AST/Availability.cpp

@@ -64,6 +64,30 @@ AvailabilityRange AvailabilityRange::forRuntimeTarget(const ASTContext &Ctx) {
   return AvailabilityRange(VersionRange::allGTE(Ctx.LangOpts.RuntimeVersion));
 }
 
+std::optional<AvailabilityRange>
+UnmetAvailabilityRequirement::getRequiredNewerAvailabilityRange(
+    ASTContext &ctx) const {
+  switch (kind) {
+  case Kind::AlwaysUnavailable:
+  case Kind::RequiresVersion:
+  case Kind::Obsoleted:
+    return std::nullopt;
+  case Kind::IntroducedInNewerVersion:
+    return AvailabilityInference::availableRange(attr, ctx);
+  }
+}
+
+bool UnmetAvailabilityRequirement::isConditionallySatisfiable() const {
+  switch (kind) {
+  case Kind::AlwaysUnavailable:
+  case Kind::RequiresVersion:
+  case Kind::Obsoleted:
+    return false;
+  case Kind::IntroducedInNewerVersion:
+    return true;
+  }
+}
+
 namespace {
 
 /// The inferred availability required to access a group of declarations

lib/Sema/BuilderTransform.cpp

@@ -1321,12 +1321,8 @@ ResultBuilderOpSupport TypeChecker::checkBuilderOpSupport(
     ArrayRef<Identifier> argLabels, SmallVectorImpl<ValueDecl *> *allResults) {
 
   auto isUnavailable = [&](Decl *D) -> bool {
-    if (AvailableAttr::isUnavailable(D))
-      return true;
-
     auto loc = extractNearestSourceLoc(dc);
-    auto context = ExportContext::forFunctionBody(dc, loc);
-    return TypeChecker::checkDeclarationAvailability(D, context).has_value();
+    return getUnmetDeclAvailabilityRequirement(D, dc, loc).has_value();
   };
 
   bool foundMatch = false;

lib/Sema/CSSyntacticElement.cpp

@@ -2475,10 +2475,9 @@ class ResultBuilderRewriter : public SyntacticElementSolutionApplication {
       if (!nominal)
         return false;
 
-      ExportContext where =
-          ExportContext::forFunctionBody(context.getAsDeclContext(), loc);
-      if (auto reason =
-              TypeChecker::checkDeclarationAvailability(nominal, where)) {
+      auto unmetRequirement = getUnmetDeclAvailabilityRequirement(
+          nominal, context.getAsDeclContext(), loc);
+      if (unmetRequirement && unmetRequirement->isConditionallySatisfiable()) {
         auto &ctx = getASTContext();
         ctx.Diags.diagnose(loc,
                            diag::result_builder_missing_limited_availability,

lib/Sema/ConstraintSystem.cpp

@@ -4682,8 +4682,7 @@ bool ConstraintSystem::isDeclUnavailable(const Decl *D,
       loc = getLoc(anchor);
   }
 
-  auto availabilityContext = TypeChecker::availabilityAtLocation(loc, DC);
-  return checkDeclarationAvailability(D, DC, availabilityContext).has_value();
+  return getUnmetDeclAvailabilityRequirement(D, DC, loc).has_value();
 }
 
 bool ConstraintSystem::isConformanceUnavailable(ProtocolConformanceRef conformance,
@@ -4898,12 +4897,12 @@ bool ConstraintSystem::isReadOnlyKeyPathComponent(
   // If the setter is unavailable, then the keypath ought to be read-only
   // in this context.
   if (auto setter = storage->getOpaqueAccessor(AccessorKind::Set)) {
-    ExportContext where = ExportContext::forFunctionBody(DC, referenceLoc);
-    auto maybeUnavail =
-        TypeChecker::checkDeclarationAvailability(setter, where);
-    if (maybeUnavail.has_value()) {
+    // FIXME: Fully unavailable setters should cause the key path to be
+    // readonly too.
+    auto unmetRequirement =
+        getUnmetDeclAvailabilityRequirement(setter, DC, referenceLoc);
+    if (unmetRequirement && unmetRequirement->isConditionallySatisfiable())
       return true;
-    }
   }
 
   return false;

lib/Sema/TypeCheckAvailability.cpp

@@ -316,19 +316,6 @@ ExportContext::getExportabilityReason() const {
   return std::nullopt;
 }
 
-std::optional<AvailabilityRange>
-UnmetAvailabilityRequirement::getRequiredNewerAvailabilityRange(
-    ASTContext &ctx) const {
-  switch (kind) {
-  case Kind::AlwaysUnavailable:
-  case Kind::RequiresVersion:
-  case Kind::Obsoleted:
-    return std::nullopt;
-  case Kind::IntroducedInNewerVersion:
-    return AvailabilityInference::availableRange(attr, ctx);
-  }
-}
-
 /// Returns the first availability attribute on the declaration that is active
 /// on the target platform.
 static const AvailableAttr *getActiveAvailableAttribute(const Decl *D,
@@ -1478,62 +1465,6 @@ AvailabilityRange TypeChecker::overApproximateAvailabilityAtLocation(
   return availabilityAtLocation(loc, DC, MostRefined).getPlatformRange();
 }
 
-bool TypeChecker::isDeclarationUnavailable(
-    const Decl *D, const DeclContext *referenceDC,
-    llvm::function_ref<AvailabilityRange()> getAvailabilityRange) {
-  ASTContext &Context = referenceDC->getASTContext();
-  if (Context.LangOpts.DisableAvailabilityChecking) {
-    return false;
-  }
-
-  if (!referenceDC->getParentSourceFile()) {
-    // We only check availability if this reference is in a source file; we do
-    // not check in other kinds of FileUnits.
-    return false;
-  }
-
-  AvailabilityRange safeRangeUnderApprox{
-      AvailabilityInference::availableRange(D)};
-
-  if (safeRangeUnderApprox.isAlwaysAvailable())
-    return false;
-
-  AvailabilityRange runningOSOverApprox = getAvailabilityRange();
-
-  // The reference is safe if an over-approximation of the running OS
-  // versions is fully contained within an under-approximation
-  // of the versions on which the declaration is available. If this
-  // containment cannot be guaranteed, we say the reference is
-  // not available.
-  return !runningOSOverApprox.isContainedIn(safeRangeUnderApprox);
-}
-
-std::optional<AvailabilityRange>
-TypeChecker::checkDeclarationAvailability(const Decl *D,
-                                          const ExportContext &Where) {
-  // Skip computing potential unavailability if the declaration is explicitly
-  // unavailable and the context is also unavailable.
-  if (const AvailableAttr *Attr = AvailableAttr::isUnavailable(D))
-    if (isInsideCompatibleUnavailableDeclaration(D, Where.getAvailability(),
-                                                 Attr))
-      return std::nullopt;
-
-  if (isDeclarationUnavailable(D, Where.getDeclContext(), [&Where] {
-        return Where.getAvailabilityRange();
-      })) {
-    return AvailabilityInference::availableRange(D);
-  }
-
-  return std::nullopt;
-}
-
-std::optional<AvailabilityRange>
-TypeChecker::checkConformanceAvailability(const RootProtocolConformance *conf,
-                                          const ExtensionDecl *ext,
-                                          const ExportContext &where) {
-  return checkDeclarationAvailability(ext, where);
-}
-
 /// A class that walks the AST to find the innermost (i.e., deepest) node that
 /// contains a target SourceRange and matches a particular criterion.
 /// This class finds the innermost nodes of interest by walking
@@ -2275,12 +2206,14 @@ behaviorLimitForExplicitUnavailability(
 
 /// Emits a diagnostic for a protocol conformance that is potentially
 /// unavailable at the given source location.
-static void
+static bool
 diagnosePotentialUnavailability(const RootProtocolConformance *rootConf,
                                 const ExtensionDecl *ext, SourceLoc loc,
                                 const DeclContext *dc,
                                 const AvailabilityRange &availability) {
   ASTContext &ctx = dc->getASTContext();
+  if (ctx.LangOpts.DisableAvailabilityChecking)
+    return false;
 
   {
     auto type = rootConf->getType();
@@ -2296,10 +2229,11 @@ diagnosePotentialUnavailability(const RootProtocolConformance *rootConf,
     // Direct a fixit to the error if an existing guard is nearly-correct
     if (fixAvailabilityByNarrowingNearbyVersionCheck(loc, dc, availability, ctx,
                                                      err))
-      return;
+      return true;
   }
 
   fixAvailability(loc, dc, availability, ctx);
+  return true;
 }
 
 /// Returns the availability attribute indicating deprecation of the
@@ -3099,9 +3033,9 @@ bool diagnoseExplicitUnavailability(
 }
 
 std::optional<UnmetAvailabilityRequirement>
-swift::checkDeclarationAvailability(const Decl *decl,
-                                    const DeclContext *declContext,
-                                    AvailabilityContext availabilityContext) {
+swift::getUnmetDeclAvailabilityRequirement(
+    const Decl *decl, const DeclContext *declContext,
+    AvailabilityContext availabilityContext) {
   auto &ctx = declContext->getASTContext();
 
   // Generic parameters are always available.
@@ -3140,6 +3074,14 @@ swift::checkDeclarationAvailability(const Decl *decl,
   return std::nullopt;
 }
 
+std::optional<UnmetAvailabilityRequirement>
+swift::getUnmetDeclAvailabilityRequirement(const Decl *decl,
+                                           const DeclContext *referenceDC,
+                                           SourceLoc referenceLoc) {
+  return getUnmetDeclAvailabilityRequirement(
+      decl, referenceDC,
+      TypeChecker::availabilityAtLocation(referenceLoc, referenceDC));
+}
 
 /// Check if this is a subscript declaration inside String or
 /// Substring that returns String, and if so return true.
@@ -4153,13 +4095,9 @@ bool swift::diagnoseDeclAvailability(const ValueDecl *D, SourceRange R,
   auto &ctx = DC->getASTContext();
 
   auto unmetRequirement =
-      checkDeclarationAvailability(D, DC, Where.getAvailability());
-  auto requiredRange =
-      unmetRequirement
-          ? unmetRequirement->getRequiredNewerAvailabilityRange(ctx)
-          : std::nullopt;
+      getUnmetDeclAvailabilityRequirement(D, DC, Where.getAvailability());
 
-  if (unmetRequirement && !requiredRange) {
+  if (unmetRequirement && !unmetRequirement->isConditionallySatisfiable()) {
     // FIXME: diagnoseExplicitUnavailability should take an unmet requirement
     if (diagnoseExplicitUnavailability(D, R, Where, call, Flags))
       return true;
@@ -4183,6 +4121,11 @@ bool swift::diagnoseDeclAvailability(const ValueDecl *D, SourceRange R,
         && isa<ProtocolDecl>(D))
     return false;
 
+  if (!unmetRequirement)
+    return false;
+
+  auto requiredRange = unmetRequirement->getRequiredNewerAvailabilityRange(ctx);
+
   // Diagnose (and possibly signal) for potential unavailability
   if (!requiredRange)
     return false;
@@ -4630,6 +4573,7 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
   // Diagnose "missing" conformances where we needed a conformance but
   // didn't have one.
   auto *DC = where.getDeclContext();
+  auto &ctx = DC->getASTContext();
   if (auto builtinConformance = dyn_cast<BuiltinProtocolConformance>(rootConf)){
     if (builtinConformance->isMissing()) {
       diagnoseMissingConformance(loc, builtinConformance->getType(),
@@ -4643,7 +4587,6 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
 
     Type selfTy = rootConf->getProtocol()->getSelfInterfaceType();
     if (!depTy->isEqual(selfTy)) {
-      auto &ctx = DC->getASTContext();
       ctx.Diags.diagnose(
           loc,
           diag::assoc_conformance_from_implementation_only_module,
@@ -4658,20 +4601,26 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
       return true;
     }
 
-    if (diagnoseExplicitUnavailability(loc, rootConf, ext, where,
-                                       warnIfConformanceUnavailablePreSwift6)) {
-      maybeEmitAssociatedTypeNote();
-      return true;
-    }
+    auto unmetRequirement = getUnmetDeclAvailabilityRequirement(
+        ext, where.getDeclContext(), where.getAvailability());
+    if (unmetRequirement) {
+      // FIXME: diagnoseExplicitUnavailability() should take unmet requirement
+      if (diagnoseExplicitUnavailability(
+              loc, rootConf, ext, where,
+              warnIfConformanceUnavailablePreSwift6)) {
+        maybeEmitAssociatedTypeNote();
+        return true;
+      }
 
-    // Diagnose (and possibly signal) for potential unavailability
-    auto maybeUnavail = TypeChecker::checkConformanceAvailability(
-        rootConf, ext, where);
-    if (maybeUnavail.has_value()) {
-      diagnosePotentialUnavailability(rootConf, ext, loc, DC,
-                                      maybeUnavail.value());
-      maybeEmitAssociatedTypeNote();
-      return true;
+      // Diagnose (and possibly signal) for potential unavailability
+      if (auto requiredRange =
+              unmetRequirement->getRequiredNewerAvailabilityRange(ctx)) {
+        if (diagnosePotentialUnavailability(rootConf, ext, loc, DC,
+                                            *requiredRange)) {
+          maybeEmitAssociatedTypeNote();
+          return true;
+        }
+      }
     }
 
     // Diagnose for deprecation