AST: Rename AvailabilityContext to AvailabilityRange.

The generality of the `AvailabilityContext` name made it seem like it
encapsulates more than it does. Really it just augments `VersionRange` with
additional set algebra operations that are useful for availability
computations. The `AvailabilityContext` name should be reserved for something
pulls together more than just a single version.

Author: tshortli

include/swift/AST/ASTContext.h

@@ -69,7 +69,7 @@ namespace swift {
   class AbstractFunctionDecl;
   class ASTContext;
   enum class Associativity : unsigned char;
-  class AvailabilityContext;
+  class AvailabilityRange;
   class BoundGenericType;
   class BuiltinTupleDecl;
   class ClangModuleLoader;
@@ -870,25 +870,25 @@ class ASTContext final {
 
   /// Get the availability of features introduced in the specified version
   /// of the Swift compiler for the target platform.
-  AvailabilityContext getSwiftAvailability(unsigned major, unsigned minor) const;
+  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
-  // AvailabilityContext::forRuntimeTarget(), and only looks at the Swift
+  // AvailabilityRange::forRuntimeTarget(), and only looks at the Swift
   // runtime version.
-#define FEATURE(N, V)                                                       \
-  inline AvailabilityContext get##N##Availability() const {                 \
-    return getSwiftAvailability V;                                          \
-  }                                                                         \
-  inline AvailabilityContext get##N##RuntimeAvailability() const {          \
-    return AvailabilityContext(VersionRange::allGTE(llvm::VersionTuple V)); \
+#define FEATURE(N, V)                                                          \
+  inline AvailabilityRange get##N##Availability() const {                      \
+    return getSwiftAvailability V;                                             \
+  }                                                                            \
+  inline AvailabilityRange get##N##RuntimeAvailability() const {               \
+    return AvailabilityRange(VersionRange::allGTE(llvm::VersionTuple V));      \
   }
 
-  #include "swift/AST/FeatureAvailability.def"
+#include "swift/AST/FeatureAvailability.def"
 
   /// Get the runtime availability of features that have been introduced in the
   /// Swift compiler for future versions of the target platform.
-  AvailabilityContext getSwiftFutureAvailability() const;
+  AvailabilityRange getSwiftFutureAvailability() const;
 
   /// Returns `true` if versioned availability annotations are supported for the
   /// target triple.
@@ -903,86 +903,86 @@ class ASTContext final {
 
   /// Get the runtime availability of features introduced in the Swift 5.0
   /// compiler for the target platform.
-  inline AvailabilityContext getSwift50Availability() const {
+  inline AvailabilityRange getSwift50Availability() const {
     return getSwiftAvailability(5, 0);
   }
 
   /// Get the runtime availability of features introduced in the Swift 5.1
   /// compiler for the target platform.
-  inline AvailabilityContext getSwift51Availability() const {
+  inline AvailabilityRange getSwift51Availability() const {
     return getSwiftAvailability(5, 1);
   }
 
   /// Get the runtime availability of features introduced in the Swift 5.2
   /// compiler for the target platform.
-  inline AvailabilityContext getSwift52Availability() const {
+  inline AvailabilityRange getSwift52Availability() const {
     return getSwiftAvailability(5, 2);
   }
 
   /// Get the runtime availability of features introduced in the Swift 5.3
   /// compiler for the target platform.
-  inline AvailabilityContext getSwift53Availability() const {
+  inline AvailabilityRange getSwift53Availability() const {
     return getSwiftAvailability(5, 3);
   }
 
   /// Get the runtime availability of features introduced in the Swift 5.4
   /// compiler for the target platform.
-  inline AvailabilityContext getSwift54Availability() const {
+  inline AvailabilityRange getSwift54Availability() const {
     return getSwiftAvailability(5, 4);
   }
 
   /// Get the runtime availability of features introduced in the Swift 5.5
   /// compiler for the target platform.
-  inline AvailabilityContext getSwift55Availability() const {
+  inline AvailabilityRange getSwift55Availability() const {
     return getSwiftAvailability(5, 5);
   }
 
   /// Get the runtime availability of features introduced in the Swift 5.6
   /// compiler for the target platform.
-  inline AvailabilityContext getSwift56Availability() const {
+  inline AvailabilityRange getSwift56Availability() const {
     return getSwiftAvailability(5, 6);
   }
 
   /// Get the runtime availability of features introduced in the Swift 5.7
   /// compiler for the target platform.
-  inline AvailabilityContext getSwift57Availability() const {
+  inline AvailabilityRange getSwift57Availability() const {
     return getSwiftAvailability(5, 7);
   }
 
   /// Get the runtime availability of features introduced in the Swift 5.8
   /// compiler for the target platform.
-  inline AvailabilityContext getSwift58Availability() const {
+  inline AvailabilityRange getSwift58Availability() const {
     return getSwiftAvailability(5, 8);
   }
 
   /// Get the runtime availability of features introduced in the Swift 5.9
   /// compiler for the target platform.
-  inline AvailabilityContext getSwift59Availability() const {
+  inline AvailabilityRange getSwift59Availability() const {
     return getSwiftAvailability(5, 9);
   }
 
   /// Get the runtime availability of features introduced in the Swift 5.10
   /// compiler for the target platform.
-  inline AvailabilityContext getSwift510Availability() const {
+  inline AvailabilityRange getSwift510Availability() const {
     return getSwiftAvailability(5, 10);
   }
 
   /// Get the runtime availability of features introduced in the Swift 6.0
   /// compiler for the target platform.
-  inline AvailabilityContext getSwift60Availability() const {
+  inline AvailabilityRange getSwift60Availability() const {
     return getSwiftAvailability(6, 0);
   }
 
   /// Get the runtime availability for a particular version of Swift (5.0+).
-  inline AvailabilityContext
+  inline AvailabilityRange
   getSwift5PlusAvailability(llvm::VersionTuple swiftVersion) const {
     return getSwiftAvailability(swiftVersion.getMajor(),
                                 *swiftVersion.getMinor());
   }
 
   /// Get the runtime availability of getters and setters of multi payload enum
   /// tag single payloads.
-  inline AvailabilityContext getMultiPayloadEnumTagSinglePayload() const {
+  inline AvailabilityRange getMultiPayloadEnumTagSinglePayload() const {
     // This didn't fit the pattern, so needed renaming
     return getMultiPayloadEnumTagSinglePayloadAvailability();
   }

include/swift/AST/Availability.h

@@ -196,45 +196,45 @@ class VersionRange {
 
 /// Represents a version range in which something is available.
 ///
-/// The AvailabilityContext structure forms a [lattice][], which allows it to
+/// The AvailabilityRange structure forms a [lattice][], which allows it to
 /// have meaningful union and intersection operations ("join" and "meet"),
 /// which use conservative approximations to prevent availability violations.
 /// See #unionWith, #intersectWith, and #constrainWith.
 ///
 /// [lattice]: http://mathworld.wolfram.com/Lattice.html
 ///
 /// NOTE: Generally you should use the utilities on \c AvailabilityInference
-/// to create an \c AvailabilityContext, rather than creating one directly.
-class AvailabilityContext {
+/// to create an \c AvailabilityRange, rather than creating one directly.
+class AvailabilityRange {
   VersionRange Range;
 
 public:
-  explicit AvailabilityContext(VersionRange Range) : Range(Range) {}
+  explicit AvailabilityRange(VersionRange Range) : Range(Range) {}
 
   /// Creates a context that imposes the constraints of the ASTContext's
   /// deployment target.
-  static AvailabilityContext forDeploymentTarget(const ASTContext &Ctx);
+  static AvailabilityRange forDeploymentTarget(const ASTContext &Ctx);
 
   /// Creates a context that imposes the constraints of the ASTContext's
   /// inlining target (i.e. minimum inlining version).
-  static AvailabilityContext forInliningTarget(const ASTContext &Ctx);
+  static AvailabilityRange forInliningTarget(const ASTContext &Ctx);
 
   /// Creates a context that imposes the constraints of the ASTContext's
   /// minimum runtime version.
-  static AvailabilityContext forRuntimeTarget(const ASTContext &Ctx);
+  static AvailabilityRange forRuntimeTarget(const ASTContext &Ctx);
 
   /// Creates a context that imposes no constraints.
   ///
   /// \see isAlwaysAvailable
-  static AvailabilityContext alwaysAvailable() {
-    return AvailabilityContext(VersionRange::all());
+  static AvailabilityRange alwaysAvailable() {
+    return AvailabilityRange(VersionRange::all());
   }
 
   /// Creates a context that can never actually occur.
   ///
   /// \see isKnownUnreachable
-  static AvailabilityContext neverAvailable() {
-    return AvailabilityContext(VersionRange::empty());
+  static AvailabilityRange neverAvailable() {
+    return AvailabilityRange(VersionRange::empty());
   }
 
   /// Returns the range of possible versions required by this context.
@@ -245,7 +245,7 @@ class AvailabilityContext {
 
   /// Returns the minimum version required by this context. This convenience
   /// is meant for debugging, diagnostics, serialization, etc. Use of the set
-  /// algebra operations on `AvailabilityContext` should be preferred over
+  /// algebra operations on `AvailabilityRange` should be preferred over
   /// direct comparison of raw versions.
   ///
   /// Only call when `hasMinimumVersion()` returns true.
@@ -256,14 +256,14 @@ class AvailabilityContext {
   /// Returns true if \p other makes stronger guarantees than this context.
   ///
   /// That is, `a.isContainedIn(b)` implies `a.union(b) == b`.
-  bool isContainedIn(const AvailabilityContext &other) const {
+  bool isContainedIn(const AvailabilityRange &other) const {
     return Range.isContainedIn(other.Range);
   }
 
   /// Returns true if \p other is a strict subset of this context.
   ///
   /// That is, `a.isSupersetOf(b)` implies `a != b` and `a.union(b) == a`.
-  bool isSupersetOf(const AvailabilityContext &other) const {
+  bool isSupersetOf(const AvailabilityRange &other) const {
     return Range.isSupersetOf(other.Range);
   }
 
@@ -291,7 +291,7 @@ class AvailabilityContext {
   ///
   /// As an example, this is used when figuring out the required availability
   /// for a type that references multiple nominal decls.
-  void intersectWith(const AvailabilityContext &other) {
+  void intersectWith(const AvailabilityRange &other) {
     Range.intersectWith(other.Range);
   }
 
@@ -302,7 +302,7 @@ class AvailabilityContext {
   /// treating some invalid deployment environments as available.
   ///
   /// As an example, this is used for the true branch of `#available`.
-  void constrainWith(const AvailabilityContext &other) {
+  void constrainWith(const AvailabilityRange &other) {
     Range.constrainWith(other.Range);
   }
 
@@ -314,13 +314,13 @@ class AvailabilityContext {
   ///
   /// As an example, this is used for the else branch of a conditional with
   /// multiple `#available` checks.
-  void unionWith(const AvailabilityContext &other) {
+  void unionWith(const AvailabilityRange &other) {
     Range.unionWith(other.Range);
   }
 
   /// Returns a representation of this range as a string for debugging purposes.
   std::string getAsString() const {
-    return "AvailabilityContext(" + getVersionString() + ")";
+    return "AvailabilityRange(" + getVersionString() + ")";
   }
 
   /// Returns a representation of the raw version range as a string for
@@ -345,11 +345,11 @@ class AvailabilityInference {
                               ArrayRef<const Decl *> InferredFromDecls,
                               ASTContext &Context);
 
-  static AvailabilityContext inferForType(Type t);
+  static AvailabilityRange inferForType(Type t);
 
   /// Returns the context where a declaration is available
   /// We assume a declaration without an annotation is always available.
-  static AvailabilityContext availableRange(const Decl *D, ASTContext &C);
+  static AvailabilityRange availableRange(const Decl *D, ASTContext &C);
 
   /// Returns true is the declaration is `@_spi_available`.
   static bool isAvailableAsSPI(const Decl *D, ASTContext &C);
@@ -358,8 +358,8 @@ class AvailabilityInference {
   /// @available attribute.
   ///
   /// NOTE: The attribute must be active on the current platform.
-  static AvailabilityContext availableRange(const AvailableAttr *attr,
-                                            ASTContext &C);
+  static AvailabilityRange availableRange(const AvailableAttr *attr,
+                                          ASTContext &C);
 
   /// Returns the attribute that should be used to determine the availability
   /// range of the given declaration, or nullptr if there is none.
@@ -369,10 +369,10 @@ class AvailabilityInference {
   /// Returns the context for which the declaration
   /// is annotated as available, or None if the declaration
   /// has no availability annotation.
-  static std::optional<AvailabilityContext>
+  static std::optional<AvailabilityRange>
   annotatedAvailableRange(const Decl *D, ASTContext &C);
 
-  static AvailabilityContext
+  static AvailabilityRange
   annotatedAvailableRangeForAttr(const SpecializeAttr *attr, ASTContext &ctx);
 
   /// For the attribute's introduction version, update the platform and version

include/swift/AST/Decl.h

@@ -64,7 +64,7 @@ namespace swift {
   enum class AccessSemantics : unsigned char;
   class AccessorDecl;
   class ApplyExpr;
-  class AvailabilityContext;
+  class AvailabilityRange;
   class GenericEnvironment;
   class ArchetypeType;
   class ASTContext;
@@ -1326,7 +1326,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     return getAttrs().hasAttribute<NoImplicitCopyAttr>();
   }
 
-  AvailabilityContext getAvailabilityForLinkage() const;
+  AvailabilityRange getAvailabilityForLinkage() const;
 
   /// Whether this declaration or one of its outer contexts has the
   /// @_weakLinked attribute.

include/swift/AST/RequirementMatch.h

@@ -255,19 +255,19 @@ struct RequirementCheck {
 
   /// The required availability, if the check failed due to the
   /// witness being less available than the requirement.
-  AvailabilityContext RequiredAvailability;
+  AvailabilityRange RequiredAvailability;
 
   RequirementCheck(CheckKind kind)
-    : Kind(kind), RequiredAccessScope(AccessScope::getPublic()),
-      RequiredAvailability(AvailabilityContext::alwaysAvailable()) { }
+      : Kind(kind), RequiredAccessScope(AccessScope::getPublic()),
+        RequiredAvailability(AvailabilityRange::alwaysAvailable()) {}
 
   RequirementCheck(CheckKind kind, AccessScope requiredAccessScope)
-    : Kind(kind), RequiredAccessScope(requiredAccessScope),
-      RequiredAvailability(AvailabilityContext::alwaysAvailable()) { }
+      : Kind(kind), RequiredAccessScope(requiredAccessScope),
+        RequiredAvailability(AvailabilityRange::alwaysAvailable()) {}
 
-  RequirementCheck(CheckKind kind, AvailabilityContext requiredAvailability)
-    : Kind(kind), RequiredAccessScope(AccessScope::getPublic()),
-      RequiredAvailability(requiredAvailability) { }
+  RequirementCheck(CheckKind kind, AvailabilityRange requiredAvailability)
+      : Kind(kind), RequiredAccessScope(AccessScope::getPublic()),
+        RequiredAvailability(requiredAvailability) {}
 };