AST/Sema: Sink AvailabilityContext for location queries from Sema to AST.

Author: tshortli

include/swift/AST/AvailabilityContext.h

@@ -28,7 +28,9 @@
 namespace swift {
 class ASTContext;
 class AvailableAttr;
+class AvailabilityScope;
 class Decl;
+class DeclContext;
 
 /// An `AvailabilityContext` summarizes the availability constraints for a
 /// specific scope, such as within a declaration or at a particular source
@@ -62,6 +64,17 @@ class AvailabilityContext {
   /// set to the deployment target.
   static AvailabilityContext forDeploymentTarget(const ASTContext &ctx);
 
+  /// Returns the most refined `AvailabilityContext` for the given source
+  /// location. If `refinedScope` is not `nullptr`, it will be set to the most
+  /// refined scope that contains the location.
+  static AvailabilityContext
+  forLocation(SourceLoc loc, const DeclContext *declContext,
+              const AvailabilityScope **refinedScope = nullptr);
+
+  /// Returns the availability context of the signature (rather than the body)
+  /// of the given declaration.
+  static AvailabilityContext forDeclSignature(const Decl *decl);
+
   /// Returns the range of platform versions which may execute code in the
   /// availability context, starting at its introduction version.
   // FIXME: [availability] Remove; superseded by getAvailableRange().

lib/AST/AvailabilityContext.cpp

@@ -15,7 +15,9 @@
 #include "swift/AST/AvailabilityConstraint.h"
 #include "swift/AST/AvailabilityContextStorage.h"
 #include "swift/AST/AvailabilityInference.h"
+#include "swift/AST/AvailabilityScope.h"
 #include "swift/AST/Decl.h"
+#include "swift/AST/Module.h"
 #include "swift/Basic/Assertions.h"
 
 using namespace swift;
@@ -153,6 +155,65 @@ AvailabilityContext::forDeploymentTarget(const ASTContext &ctx) {
       AvailabilityRange::forDeploymentTarget(ctx), ctx);
 }
 
+AvailabilityContext
+AvailabilityContext::forLocation(SourceLoc loc, const DeclContext *declContext,
+                                 const AvailabilityScope **refinedScope) {
+  auto &ctx = declContext->getASTContext();
+  SourceFile *sf =
+      loc.isValid()
+          ? declContext->getParentModule()->getSourceFileContainingLocation(loc)
+          : declContext->getParentSourceFile();
+
+  // If our source location is invalid (this may be synthesized code), climb the
+  // decl context hierarchy until we find a location that is valid, merging
+  // availability contexts on the way up.
+  //
+  // Because we are traversing decl contexts, we will miss availability scopes
+  // in synthesized code that are introduced by AST elements that are themselves
+  // not decl contexts, such as `#available(..)` and property declarations.
+  // Therefore a reference with an invalid source location that is contained
+  // inside an `#available()` and with no intermediate decl context will not be
+  // refined. For now, this is fine, but if we ever synthesize #available(),
+  // this could become a problem..
+
+  // We can assume we are running on at least the minimum inlining target.
+  auto baseAvailability = AvailabilityContext::forInliningTarget(ctx);
+  auto isInvalidLoc = [sf](SourceLoc loc) {
+    return sf ? loc.isInvalid() : true;
+  };
+  while (declContext && isInvalidLoc(loc)) {
+    const Decl *decl = declContext->getInnermostDeclarationDeclContext();
+    if (!decl)
+      break;
+
+    baseAvailability.constrainWithDecl(decl);
+    loc = decl->getLoc();
+    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;
+}
+
+AvailabilityContext AvailabilityContext::forDeclSignature(const Decl *decl) {
+  return forLocation(decl->getLoc(), decl->getInnermostDeclContext());
+}
+
 AvailabilityRange AvailabilityContext::getPlatformRange() const {
   return storage->platformRange;
 }

lib/Sema/ConstraintSystem.cpp

@@ -4588,7 +4588,7 @@ Expr *ConstraintSystem::buildTypeErasedExpr(Expr *expr, DeclContext *dc,
   auto *PD = protocols.front();
 
   auto contextAvailability =
-      TypeChecker::availabilityAtLocation(expr->getLoc(), dc);
+      AvailabilityContext::forLocation(expr->getLoc(), dc);
   auto refinedAvailability =
       AvailabilityContext::forPlatformRange(
         AvailabilityRange::alwaysAvailable(), ctx);
@@ -4600,8 +4600,7 @@ Expr *ConstraintSystem::buildTypeErasedExpr(Expr *expr, DeclContext *dc,
     assert(eraser && "Failed to resolve eraser type!");
 
     auto *nominal = eraser->getAnyNominal();
-    auto nominalAvailability =
-        TypeChecker::availabilityForDeclSignature(nominal);
+    auto nominalAvailability = AvailabilityContext::forDeclSignature(nominal);
 
     if (contextAvailability.isContainedIn(nominalAvailability) &&
         nominalAvailability.isContainedIn(refinedAvailability)) {

lib/Sema/TypeCheckAttr.cpp

@@ -5089,7 +5089,7 @@ void AttributeChecker::checkAvailableAttrs(ArrayRef<AvailableAttr *> attrs) {
   auto availabilityContext = AvailabilityContext::forDeploymentTarget(Ctx);
   if (auto parent =
           AvailabilityInference::parentDeclForInferredAvailability(D)) {
-    auto parentAvailability = TypeChecker::availabilityForDeclSignature(parent);
+    auto parentAvailability = AvailabilityContext::forDeclSignature(parent);
     availabilityContext.constrainWithContext(parentAvailability, Ctx);
   }
 
@@ -5235,7 +5235,7 @@ void AttributeChecker::checkBackDeployedAttrs(
     if (Ctx.LangOpts.DisableAvailabilityChecking)
       continue;
 
-    auto availability = TypeChecker::availabilityAtLocation(
+    auto availability = AvailabilityContext::forLocation(
         D->getLoc(), D->getInnermostDeclContext());
 
     // Unavailable decls cannot be back deployed.

lib/Sema/TypeCheckAvailability.cpp

@@ -169,7 +169,7 @@ ExportContext ExportContext::forDeclSignature(Decl *D) {
   auto *DC = D->getInnermostDeclContext();
   auto fragileKind = DC->getFragileFunctionKind();
   auto loc = D->getLoc();
-  auto availabilityContext = TypeChecker::availabilityAtLocation(loc, DC);
+  auto availabilityContext = AvailabilityContext::forLocation(loc, DC);
   bool spi = Ctx.LangOpts.LibraryLevel == LibraryLevel::SPI;
   bool implicit = false;
   computeExportContextBits(Ctx, D, &spi, &implicit);
@@ -187,7 +187,7 @@ ExportContext ExportContext::forFunctionBody(DeclContext *DC, SourceLoc loc) {
   auto &Ctx = DC->getASTContext();
 
   auto fragileKind = DC->getFragileFunctionKind();
-  auto availabilityContext = TypeChecker::availabilityAtLocation(loc, DC);
+  auto availabilityContext = AvailabilityContext::forLocation(loc, DC);
   bool spi = Ctx.LangOpts.LibraryLevel == LibraryLevel::SPI;
   bool implicit = false;
   forEachOuterDecl(
@@ -288,75 +288,11 @@ static bool shouldTreatDeclContextAsAsyncForDiagnostics(const DeclContext *DC) {
   return DC->isAsyncContext();
 }
 
-AvailabilityContext
-TypeChecker::availabilityAtLocation(SourceLoc loc, const DeclContext *DC,
-                                    const AvailabilityScope **MostRefined) {
-  SourceFile *SF;
-  if (loc.isValid())
-    SF = DC->getParentModule()->getSourceFileContainingLocation(loc);
-  else
-    SF = DC->getParentSourceFile();
-  auto &Context = DC->getASTContext();
-
-  // If our source location is invalid (this may be synthesized code), climb
-  // the decl context hierarchy until we find a location that is valid,
-  // collecting availability ranges on the way up.
-  // We will combine the version ranges from these annotations
-  // with the scope for the valid location to overapproximate the running
-  // OS versions at the original source location.
-  // Because we are climbing DeclContexts we will miss availability scopes in
-  // synthesized code that are introduced by AST elements that are themselves
-  // not DeclContexts, such as  #available(..) and property declarations.
-  // That is, a reference with an invalid location that is contained
-  // inside a #available() and with no intermediate DeclContext will not be
-  // refined. For now, this is fine -- but if we ever synthesize #available(),
-  // this will be a real problem.
-
-  // We can assume we are running on at least the minimum inlining target.
-  auto baseAvailability = AvailabilityContext::forInliningTarget(Context);
-  auto isInvalidLoc = [SF](SourceLoc loc) {
-    return SF ? loc.isInvalid() : true;
-  };
-  while (DC && isInvalidLoc(loc)) {
-    const Decl *D = DC->getInnermostDeclarationDeclContext();
-    if (!D)
-      break;
-
-    baseAvailability.constrainWithDecl(D);
-    loc = D->getLoc();
-    DC = D->getDeclContext();
-  }
-
-  if (!SF || loc.isInvalid())
-    return baseAvailability;
-
-  auto *rootScope = AvailabilityScope::getOrBuildForSourceFile(*SF);
-  if (!rootScope)
-    return baseAvailability;
-
-  AvailabilityScope *scope = rootScope->findMostRefinedSubContext(loc, Context);
-  if (!scope)
-    return baseAvailability;
-
-  if (MostRefined) {
-    *MostRefined = scope;
-  }
-
-  auto availability = scope->getAvailabilityContext();
-  availability.constrainWithContext(baseAvailability, Context);
-  return availability;
-}
-
-AvailabilityContext
-TypeChecker::availabilityForDeclSignature(const Decl *decl) {
-  return TypeChecker::availabilityAtLocation(decl->getLoc(),
-                                             decl->getInnermostDeclContext());
-}
-
 AvailabilityRange TypeChecker::overApproximateAvailabilityAtLocation(
     SourceLoc loc, const DeclContext *DC,
     const AvailabilityScope **MostRefined) {
-  return availabilityAtLocation(loc, DC, MostRefined).getPlatformRange();
+  return AvailabilityContext::forLocation(loc, DC, MostRefined)
+      .getPlatformRange();
 }
 
 /// A class that walks the AST to find the innermost (i.e., deepest) node that
@@ -1831,8 +1767,7 @@ swift::getUnsatisfiedAvailabilityConstraint(const Decl *decl,
                                             const DeclContext *referenceDC,
                                             SourceLoc referenceLoc) {
   return getAvailabilityConstraintsForDecl(
-             decl,
-             TypeChecker::availabilityAtLocation(referenceLoc, referenceDC))
+             decl, AvailabilityContext::forLocation(referenceLoc, referenceDC))
       .getPrimaryConstraint();
 }
 

lib/Sema/TypeCheckDecl.cpp

@@ -1688,8 +1688,8 @@ bool TypeChecker::isAvailabilitySafeForConformance(
   assert(dc->getSelfNominalTypeDecl() &&
          "Must have a nominal or extension context");
 
-  AvailabilityContext contextForConformingDecl =
-      availabilityForDeclSignature(dc->getAsDecl());
+  auto contextForConformingDecl =
+      AvailabilityContext::forDeclSignature(dc->getAsDecl());
 
   // If the conformance is unavailable then it's irrelevant whether the witness
   // is potentially unavailable.

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1824,7 +1824,7 @@ static bool isAvailabilitySafeForOverride(ValueDecl *override,
 
   // Allow overrides that are not as available as the base decl as long as the
   // override is as available as its context.
-  auto availabilityContext = TypeChecker::availabilityForDeclSignature(
+  auto availabilityContext = AvailabilityContext::forDeclSignature(
       override->getDeclContext()->getSelfNominalTypeDecl());
 
   return availabilityContext.getPlatformRange().isContainedIn(overrideInfo);

lib/Sema/TypeCheckStorage.cpp

@@ -2694,7 +2694,7 @@ bool AbstractStorageDecl::requiresCorrespondingUnderscoredCoroutineAccessor(
   if (!ctx.supportsVersionedAvailability())
     return true;
 
-  auto modifyAvailability = TypeChecker::availabilityAtLocation({}, accessor);
+  auto modifyAvailability = AvailabilityContext::forLocation({}, accessor);
   auto featureAvailability = ctx.getCoroutineAccessorsRuntimeAvailability();
   // If accessor was introduced only after the feature was, there's no old ABI
   // to maintain.

lib/Sema/TypeChecker.h

@@ -1031,16 +1031,6 @@ bool isAvailabilitySafeForConformance(
     const ValueDecl *witness, const DeclContext *dc,
     AvailabilityRange &requiredAvailability);
 
-/// Returns the most refined `AvailabilityContext` for the given location.
-/// If `MostRefined` is not `nullptr`, it will be set to the most refined scope
-/// that contains the given location.
-AvailabilityContext
-availabilityAtLocation(SourceLoc loc, const DeclContext *DC,
-                       const AvailabilityScope **MostRefined = nullptr);
-
-/// Returns the availability context of the signature of the given declaration.
-AvailabilityContext availabilityForDeclSignature(const Decl *decl);
-
 /// Returns an over-approximation of the range of operating system versions
 /// that could the passed-in location could be executing upon for
 /// the target platform. If MostRefined != nullptr, set to the most-refined