Merge pull request swiftlang#83349 from tshortli/check-custom-domain-availability-for-conformances

Sema: Check custom domain availability during conformance checking

Author: tshortli

include/swift/AST/ASTContext.h

@@ -909,7 +909,7 @@ class ASTContext final {
   AvailabilityRange getSwiftAvailability(unsigned major, unsigned minor) const;
 
   // For each feature defined in FeatureAvailability, define two functions;
-  // the latter, with the suffix RuntimeAvailabilty, is for use with
+  // the latter, with the suffix RuntimeAvailability, is for use with
   // AvailabilityRange::forRuntimeTarget(), and only looks at the Swift
   // runtime version.
 #define FEATURE(N, V)                                                          \

include/swift/AST/DiagnosticsSema.def

@@ -7123,6 +7123,11 @@ ERROR(availability_protocol_requires_version,
       (const ProtocolDecl *, const ValueDecl *, AvailabilityDomain,
        AvailabilityRange))
 
+ERROR(availability_protocol_requirement_only_available_in,
+      none, "protocol %0 requirement %1 cannot be satisfied by %kindonly1 that "
+      "is only available in %2",
+      (const ProtocolDecl *, const ValueDecl *, AvailabilityDomain))
+
 NOTE(availability_protocol_requirement_here, none,
      "protocol requirement here", ())
 

include/swift/AST/RequirementMatch.h

@@ -12,6 +12,7 @@
 #ifndef SWIFT_AST_REQUIREMENTMATCH_H
 #define SWIFT_AST_REQUIREMENTMATCH_H
 
+#include "swift/AST/AvailabilityConstraint.h"
 #include "swift/AST/RequirementEnvironment.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/Types.h"
@@ -252,7 +253,8 @@ class RequirementCheck {
 
     /// Storage for `CheckKind::Availability`.
     struct {
-      AvailabilityRange requiredRange;
+      AvailabilityConstraint constraint;
+      AvailabilityContext requiredContext;
     } Availability;
   };
 
@@ -266,8 +268,10 @@ class RequirementCheck {
   RequirementCheck(AccessScope requiredAccessScope, bool forSetter)
       : Kind(CheckKind::Access), Access{requiredAccessScope, forSetter} {}
 
-  RequirementCheck(AvailabilityRange requiredRange)
-      : Kind(CheckKind::Availability), Availability{requiredRange} {}
+  RequirementCheck(AvailabilityConstraint constraint,
+                   AvailabilityContext requiredContext)
+      : Kind(CheckKind::Availability),
+        Availability{constraint, requiredContext} {}
 
   CheckKind getKind() const { return Kind; }
 
@@ -280,7 +284,7 @@ class RequirementCheck {
   /// True if the witness is less available than the requirement.
   bool isLessAvailable() const {
     return (Kind == CheckKind::Availability)
-               ? !Availability.requiredRange.isKnownUnreachable()
+               ? !Availability.constraint.isUnavailable()
                : false;
   }
 
@@ -291,11 +295,18 @@ class RequirementCheck {
     return Access.requiredScope;
   }
 
+  /// The availability constraint that would fail if the witness were accessed
+  /// from contexts in which the requirement is available.
+  AvailabilityConstraint getAvailabilityConstraint() const {
+    ASSERT(Kind == CheckKind::Availability);
+    return Availability.constraint;
+  }
+
   /// The required availability range for checks that failed due to the witness
   /// being less available than the requirement.
-  AvailabilityRange getRequiredAvailabilityRange() const {
+  AvailabilityContext getRequiredAvailabilityContext() const {
     ASSERT(Kind == CheckKind::Availability);
-    return Availability.requiredRange;
+    return Availability.requiredContext;
   }
 };
 

lib/AST/AvailabilityContext.cpp

@@ -18,6 +18,7 @@
 #include "swift/AST/AvailabilityScope.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/SourceFile.h"
 #include "swift/Basic/Assertions.h"
 
 using namespace swift;
@@ -155,6 +156,30 @@ AvailabilityContext::forDeploymentTarget(const ASTContext &ctx) {
       AvailabilityRange::forDeploymentTarget(ctx), ctx);
 }
 
+static AvailabilityContext
+contextForLocationInSourceFile(SourceLoc loc, SourceFile *sf,
+                               AvailabilityContext baseAvailability,
+                               const AvailabilityScope **refinedScope) {
+  if (!sf || loc.isInvalid())
+    return baseAvailability;
+
+  auto &ctx = sf->getASTContext();
+  auto *rootScope = AvailabilityScope::getOrBuildForSourceFile(*sf);
+  if (!rootScope)
+    return baseAvailability;
+
+  auto *scope = rootScope->findMostRefinedSubContext(loc, ctx);
+  if (!scope)
+    return baseAvailability;
+
+  if (refinedScope)
+    *refinedScope = scope;
+
+  auto availability = scope->getAvailabilityContext();
+  availability.constrainWithContext(baseAvailability, ctx);
+  return availability;
+}
+
 AvailabilityContext
 AvailabilityContext::forLocation(SourceLoc loc, const DeclContext *declContext,
                                  const AvailabilityScope **refinedScope) {
@@ -191,37 +216,25 @@ AvailabilityContext::forLocation(SourceLoc loc, const DeclContext *declContext,
     declContext = decl->getDeclContext();
   }
 
-  if (!sf || loc.isInvalid())
-    return baseAvailability;
-
-  auto *rootScope = AvailabilityScope::getOrBuildForSourceFile(*sf);
-  if (!rootScope)
-    return baseAvailability;
-
-  auto *scope = rootScope->findMostRefinedSubContext(loc, ctx);
-  if (!scope)
-    return baseAvailability;
-
-  if (refinedScope)
-    *refinedScope = scope;
-
-  auto availability = scope->getAvailabilityContext();
-  availability.constrainWithContext(baseAvailability, ctx);
-  return availability;
+  return contextForLocationInSourceFile(loc, sf, baseAvailability,
+                                        refinedScope);
 }
 
 AvailabilityContext AvailabilityContext::forDeclSignature(const Decl *decl) {
-  // For decls with valid source locations, query the availability scope tree.
+  // For decls with valid source locations in source files, we can query the
+  // availability scope tree.
   auto loc = decl->getLoc();
-  if (loc.isValid())
-    return forLocation(loc, decl->getInnermostDeclContext());
-
-  // Otherwise, walk the decl hierarchy to compute availability. This can't be
-  // delegated to `AvailabilityContext::forLocation()` since it walks up the
-  // `DeclContext` hierachy for invalid source locations and that may skip
-  // some declarations with availability attributes.
   auto &ctx = decl->getASTContext();
   auto availability = forInliningTarget(ctx);
+
+  if (loc.isValid()) {
+    if (auto sf = decl->getDeclContext()
+                      ->getParentModule()
+                      ->getSourceFileContainingLocation(loc))
+      return contextForLocationInSourceFile(loc, sf, availability, nullptr);
+  }
+
+  // Otherwise, just walk the decl hierarchy to compute availability.
   while (decl) {
     availability.constrainWithDecl(decl);
     decl = decl->parentDeclForAvailability();

lib/AST/AvailabilityScopeBuilder.cpp

@@ -126,7 +126,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
   }
 
   const char *stackTraceAction() const {
-    return "building availabilty scope for";
+    return "building availability scope for";
   }
 
   friend class swift::ExpandChildAvailabilityScopesRequest;
@@ -415,7 +415,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
     // 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 platform availabilty on the extension
+    // extensions without specifying platform availability on the extension
     // itself.
     if (auto *extension = dyn_cast<ExtensionDecl>(decl)) {
       auto extendedType = extension->getExtendedType();

lib/ClangImporter/ImportDecl.cpp

@@ -9750,7 +9750,7 @@ void ClangImporter::Implementation::importAttributes(
       declContext->lookupAvailabilityDomains(domainIdentifier, results);
 
       if (results.size() > 0) {
-        // FIXME: [availability] Diagnose ambiguous availabilty domain name?
+        // FIXME: [availability] Diagnose ambiguous availability domain name?
         auto AttrKind = avail->getUnavailable()
                             ? AvailableAttr::Kind::Unavailable
                             : AvailableAttr::Kind::Default;

lib/SILGen/SILGenAvailability.cpp

@@ -267,7 +267,7 @@ SILGenFunction::emitIfAvailableQuery(SILLocation loc,
 
   // The query may not have been computed by Sema under the following
   // conditions:
-  // - Availability checking was disabled (-disable-availabilty-checking).
+  // - Availability checking was disabled (-disable-availability-checking).
   // - The query was marked invalid in the AST for a non-fatal reason.
   //
   // Otherwise, there's a bug in Sema.

lib/Sema/TypeCheckDecl.cpp

@@ -1670,72 +1670,6 @@ SelfAccessKindRequest::evaluate(Evaluator &evaluator, FuncDecl *FD) const {
   return SelfAccessKind::NonMutating;
 }
 
-bool TypeChecker::isAvailabilitySafeForConformance(
-    const ProtocolDecl *proto, const ValueDecl *requirement,
-    const ValueDecl *witness, const DeclContext *dc,
-    AvailabilityRange &requirementInfo) {
-
-  // We assume conformances in
-  // non-SourceFiles have already been checked for availability.
-  if (!dc->getParentSourceFile())
-    return true;
-
-  auto &Context = proto->getASTContext();
-  assert(dc->getSelfNominalTypeDecl() &&
-         "Must have a nominal or extension context");
-
-  auto contextForConformingDecl =
-      AvailabilityContext::forDeclSignature(dc->getAsDecl());
-
-  // If the conformance is unavailable then it's irrelevant whether the witness
-  // is potentially unavailable.
-  if (contextForConformingDecl.isUnavailable())
-    return true;
-
-  // Make sure that any access of the witness through the protocol
-  // can only occur when the witness is available. That is, make sure that
-  // on every version where the conforming declaration is available, if the
-  // requirement is available then the witness is available as well.
-  // We do this by checking that (an over-approximation of) the intersection of
-  // the requirement's available range with both the conforming declaration's
-  // available range and the protocol's available range is fully contained in
-  // (an over-approximation of) the intersection of the witnesses's available
-  // range with both the conforming type's available range and the protocol
-  // declaration's available range.
-  AvailabilityRange witnessInfo =
-      AvailabilityInference::availableRange(witness);
-  requirementInfo = AvailabilityInference::availableRange(requirement);
-
-  AvailabilityRange infoForConformingDecl =
-      contextForConformingDecl.getPlatformRange();
-
-  // Relax the requirements for @_spi witnesses by treating the requirement as
-  // if it were introduced at the deployment target. This is not strictly sound
-  // since clients of SPI do not necessarily have the same deployment target as
-  // the module declaring the requirement. However, now that the public
-  // declarations in API libraries are checked according to the minimum possible
-  // deployment target of their clients this relaxation is needed for source
-  // compatibility with some existing code and is reasonably safe for the
-  // majority of cases.
-  if (witness->isSPI()) {
-    AvailabilityRange deploymentTarget =
-        AvailabilityRange::forDeploymentTarget(Context);
-    requirementInfo.constrainWith(deploymentTarget);
-  }
-
-  // Constrain over-approximates intersection of version ranges.
-  witnessInfo.constrainWith(infoForConformingDecl);
-  requirementInfo.constrainWith(infoForConformingDecl);
-
-  AvailabilityRange infoForProtocolDecl =
-      AvailabilityContext::forDeclSignature(proto).getPlatformRange();
-
-  witnessInfo.constrainWith(infoForProtocolDecl);
-  requirementInfo.constrainWith(infoForProtocolDecl);
-
-  return requirementInfo.isContainedIn(witnessInfo);
-}
-
 // Returns 'nullptr' if this is the 'newValue' or 'oldValue' parameter;
 // otherwise, returns the corresponding parameter of the subscript
 // declaration.