AST: Introduce AvailabilityContext.

This class is designed to be a compact representation of the active
availability constraints in a specific scope. For now, it only models platform
introduction availability but it will soon be updated to cover additional
availability constraints, like platform unavailability.

In anticipation of needing to reference `AvailabilityContext`s from
`TypeRefinementContext`s and increasing memory requirements for these contexts,
a cache of uniqued instances of `AvailabilityContext` are stored in a
`llvm::FoldingSet` on `ASTContext`.

Author: tshortli

include/swift/AST/Availability.h

@@ -17,8 +17,10 @@
 #ifndef SWIFT_AST_AVAILABILITY_H
 #define SWIFT_AST_AVAILABILITY_H
 
+#include "swift/AST/PlatformKind.h"
 #include "swift/AST/Type.h"
 #include "swift/Basic/LLVM.h"
+#include "llvm/ADT/FoldingSet.h"
 #include "llvm/Support/VersionTuple.h"
 #include <optional>
 
@@ -174,6 +176,8 @@ class VersionRange {
     return VersionRange(EndPoint);
   }
 
+  void Profile(llvm::FoldingSetNodeID &ID) const;
+
 private:
   VersionRange(const llvm::VersionTuple &LowerEndpoint) {
     setLowerEndpoint(LowerEndpoint);
@@ -331,6 +335,80 @@ class AvailabilityRange {
   }
 };
 
+/// An `AvailabilityContext` summarizes the availability constraints for a
+/// specific scope, such as within a declaration or at a particular source
+/// location in a function body. This context is sufficient to determine whether
+/// a declaration is available or not in that scope.
+class AvailabilityContext : public llvm::FoldingSetNode {
+  /// Summarizes platform specific availability constraints.
+  struct PlatformInfo {
+    /// The introduction version.
+    AvailabilityRange Range;
+
+    /// Sets `Range` to `other` if `other` is more restrictive. Returns true if
+    /// any property changed as a result of adding this constraint.
+    bool constrainRange(const AvailabilityRange &other) {
+      if (!other.isContainedIn(Range))
+        return false;
+
+      Range = other;
+      return true;
+    }
+
+    /// Sets `Range` to the platform introduction range of `decl` if that range
+    /// is more restrictive. Returns true if
+    /// any property changed as a result of adding this constraint.
+    bool constrainRange(const Decl *decl);
+
+    void Profile(llvm::FoldingSetNodeID &ID) const {
+      Range.getRawVersionRange().Profile(ID);
+    }
+  };
+  PlatformInfo PlatformAvailability;
+
+  AvailabilityContext(const PlatformInfo &platformInfo)
+      : PlatformAvailability(platformInfo){};
+
+  static const AvailabilityContext *get(const PlatformInfo &platformInfo,
+                                        ASTContext &ctx);
+
+public:
+  /// Retrieves the default `AvailabilityContext`, which is maximally available.
+  /// The platform availability range will be set to the deployment target (or
+  /// minimum inlining target when applicable).
+  static const AvailabilityContext *getDefault(ASTContext &ctx);
+
+  /// Retrieves a uniqued `AvailabilityContext` with the given platform
+  /// availability parameters.
+  static const AvailabilityContext *
+  get(const AvailabilityRange &platformAvailability, ASTContext &ctx) {
+    PlatformInfo platformInfo{
+        .Range = platformAvailability,
+    };
+    return get(platformInfo, ctx);
+  }
+
+  /// Returns the range of platform versions which may execute code in the
+  /// availability context, starting at its introduction version.
+  AvailabilityRange getPlatformRange() const {
+    return PlatformAvailability.Range;
+  }
+
+  /// Returns the unique context that is the result of constraining the current
+  /// context's platform availability range with `platformRange`.
+  const AvailabilityContext *
+  constrainWithPlatformRange(const AvailabilityRange &platformRange,
+                             ASTContext &ctx) const;
+
+  /// Returns the unique context that is the result of constraining the current
+  /// context both with the availability attributes of `decl` and with
+  /// `platformRange`.
+  const AvailabilityContext *constrainWithDeclAndPlatformRange(
+      Decl *decl, const AvailabilityRange &platformRange) const;
+
+  void Profile(llvm::FoldingSetNodeID &ID) const;
+};
+
 class AvailabilityInference {
 public:
   /// Returns the decl that should be considered the parent decl of the given

lib/AST/ASTContext.cpp

@@ -593,6 +593,9 @@ struct ASTContext::Implementation {
     /// The set of substitution maps (uniqued by their storage).
     llvm::FoldingSet<SubstitutionMap::Storage> SubstitutionMaps;
 
+    /// The set of unique AvailabilityContexts.
+    llvm::FoldingSet<AvailabilityContext> AvailabilityContexts;
+
     ~Arena() {
       for (auto &conformance : SpecializedConformances)
         conformance.~SpecializedProtocolConformance();
@@ -3301,6 +3304,7 @@ void ASTContext::Implementation::Arena::dump(llvm::raw_ostream &os) const {
     SIZE_AND_BYTES(BuiltinConformances);
     SIZE(PackConformances);
     SIZE(SubstitutionMaps);
+    SIZE(AvailabilityContexts);
 
 #undef SIZE
 #undef SIZE_AND_BYTES
@@ -5577,6 +5581,26 @@ SubstitutionMap::Storage *SubstitutionMap::Storage::get(
   return result;
 }
 
+const AvailabilityContext *
+AvailabilityContext::get(const PlatformInfo &platformInfo, ASTContext &ctx) {
+  llvm::FoldingSetNodeID id;
+  platformInfo.Profile(id);
+
+  auto &foldingSet =
+      ctx.getImpl().getArena(AllocationArena::Permanent).AvailabilityContexts;
+  void *insertPos;
+  auto *existing = foldingSet.FindNodeOrInsertPos(id, insertPos);
+  if (existing)
+    return existing;
+
+  void *mem =
+      ctx.Allocate(sizeof(AvailabilityContext), alignof(AvailabilityContext));
+  auto *newNode = ::new (mem) AvailabilityContext(platformInfo);
+  foldingSet.InsertNode(newNode, insertPos);
+
+  return newNode;
+}
+
 void GenericSignatureImpl::Profile(llvm::FoldingSetNodeID &ID,
                               ArrayRef<GenericTypeParamType *> genericParams,
                               ArrayRef<Requirement> requirements) {

lib/AST/Availability.cpp

@@ -29,6 +29,26 @@
 
 using namespace swift;
 
+void VersionRange::Profile(llvm::FoldingSetNodeID &id) const {
+  id.AddBoolean(hasLowerEndpoint());
+  if (!hasLowerEndpoint()) {
+    id.AddBoolean(isAll());
+    return;
+  }
+
+  auto profileVersionComponent = [&id](std::optional<unsigned> component) {
+    id.AddBoolean(component.has_value());
+    if (component)
+      id.AddInteger(*component);
+  };
+
+  auto lowerEndpoint = getLowerEndpoint();
+  id.AddInteger(lowerEndpoint.getMajor());
+  profileVersionComponent(lowerEndpoint.getMinor());
+  profileVersionComponent(lowerEndpoint.getSubminor());
+  profileVersionComponent(lowerEndpoint.getBuild());
+}
+
 AvailabilityRange
 AvailabilityRange::forDeploymentTarget(const ASTContext &Ctx) {
   return AvailabilityRange(
@@ -44,6 +64,47 @@ AvailabilityRange AvailabilityRange::forRuntimeTarget(const ASTContext &Ctx) {
   return AvailabilityRange(VersionRange::allGTE(Ctx.LangOpts.RuntimeVersion));
 }
 
+bool AvailabilityContext::PlatformInfo::constrainRange(const Decl *decl) {
+  if (auto range = AvailabilityInference::annotatedAvailableRange(decl))
+    return constrainRange(*range);
+
+  return false;
+}
+
+const AvailabilityContext *AvailabilityContext::getDefault(ASTContext &ctx) {
+  PlatformInfo platformInfo{.Range = AvailabilityRange::forInliningTarget(ctx)};
+  return AvailabilityContext::get(platformInfo, ctx);
+}
+
+/// Returns the unique context that is the result of constraining the current
+/// context's platform availability range with `platformRange`.
+const AvailabilityContext *AvailabilityContext::constrainWithPlatformRange(
+    const AvailabilityRange &platformRange, ASTContext &ctx) const {
+  PlatformInfo platformAvailability{PlatformAvailability};
+  if (platformAvailability.constrainRange(platformRange))
+    return get(platformAvailability, ctx);
+
+  return this;
+}
+
+const AvailabilityContext *
+AvailabilityContext::constrainWithDeclAndPlatformRange(
+    Decl *decl, const AvailabilityRange &platformRange) const {
+  PlatformInfo platformAvailability{PlatformAvailability};
+  bool isConstrained = false;
+  isConstrained |= platformAvailability.constrainRange(decl);
+  isConstrained |= platformAvailability.constrainRange(platformRange);
+
+  if (!isConstrained)
+    return this;
+
+  return get(platformAvailability, decl->getASTContext());
+}
+
+void AvailabilityContext::Profile(llvm::FoldingSetNodeID &id) const {
+  PlatformAvailability.Profile(id);
+}
+
 namespace {
 
 /// The inferred availability required to access a group of declarations