Sema: Check custom domain availability during conformance checking.

Protocol requirement witnesses cannot only be available in a custom
availability domain if the requirement does not have the same availability
constraint.

Resolves rdar://156462516.

Author: tshortli

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/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.