AST: Rename AvailabilityContext's storage member.

NFC.

Author: tshortli

include/swift/AST/AvailabilityContext.h

@@ -41,9 +41,11 @@ class AvailabilityContext {
   struct PlatformInfo;
 
   /// A non-null pointer to uniqued storage for this availability context.
-  const Storage *Info;
+  const Storage *storage;
 
-  AvailabilityContext(const Storage *info) : Info(info) { assert(info); };
+  AvailabilityContext(const Storage *storage) : storage(storage) {
+    assert(storage);
+  };
 
   /// Retrieves an `AvailabilityContext` with the given platform availability
   /// parameters.
@@ -108,12 +110,12 @@ class AvailabilityContext {
 
   friend bool operator==(const AvailabilityContext &lhs,
                          const AvailabilityContext &rhs) {
-    return lhs.Info == rhs.Info;
+    return lhs.storage == rhs.storage;
   }
 
   friend bool operator!=(const AvailabilityContext &lhs,
                          const AvailabilityContext &rhs) {
-    return lhs.Info != rhs.Info;
+    return lhs.storage != rhs.storage;
   }
 
   void print(llvm::raw_ostream &os) const;

include/swift/AST/AvailabilityContextStorage.h

@@ -69,7 +69,7 @@ struct AvailabilityContext::PlatformInfo {
 /// As an implementation detail, the values that make up an `Availability`
 /// context are uniqued and stored as folding set nodes.
 class AvailabilityContext::Storage final : public llvm::FoldingSetNode {
-  Storage(const PlatformInfo &platformInfo) : Platform(platformInfo){};
+  Storage(const PlatformInfo &platformInfo) : Platform(platformInfo) {};
 
 public:
   PlatformInfo Platform;

lib/AST/AvailabilityContext.cpp

@@ -157,29 +157,29 @@ AvailabilityContext::get(const AvailabilityRange &platformAvailability,
 }
 
 AvailabilityRange AvailabilityContext::getPlatformRange() const {
-  return Info->Platform.Range;
+  return storage->Platform.Range;
 }
 
 std::optional<PlatformKind>
 AvailabilityContext::getUnavailablePlatformKind() const {
-  if (Info->Platform.IsUnavailable)
-    return Info->Platform.UnavailablePlatform;
+  if (storage->Platform.IsUnavailable)
+    return storage->Platform.UnavailablePlatform;
   return std::nullopt;
 }
 
 bool AvailabilityContext::isUnavailableInEmbedded() const {
-  return Info->Platform.IsUnavailableInEmbedded;
+  return storage->Platform.IsUnavailableInEmbedded;
 }
 
 bool AvailabilityContext::isDeprecated() const {
-  return Info->Platform.IsDeprecated;
+  return storage->Platform.IsDeprecated;
 }
 
 void AvailabilityContext::constrainWithContext(const AvailabilityContext &other,
                                                ASTContext &ctx) {
-  PlatformInfo platformAvailability{Info->Platform};
-  if (platformAvailability.constrainWith(other.Info->Platform)) {
-    Info = Storage::get(platformAvailability, ctx);
+  PlatformInfo platformAvailability{storage->Platform};
+  if (platformAvailability.constrainWith(other.storage->Platform)) {
+    storage = Storage::get(platformAvailability, ctx);
   }
 }
 
@@ -189,28 +189,28 @@ void AvailabilityContext::constrainWithDecl(const Decl *decl) {
 
 void AvailabilityContext::constrainWithPlatformRange(
     const AvailabilityRange &platformRange, ASTContext &ctx) {
-  PlatformInfo platformAvailability{Info->Platform};
+  PlatformInfo platformAvailability{storage->Platform};
   if (!constrainRange(platformAvailability.Range, platformRange))
     return;
 
-  Info = Storage::get(platformAvailability, ctx);
+  storage = Storage::get(platformAvailability, ctx);
 }
 
 void AvailabilityContext::constrainWithDeclAndPlatformRange(
     const Decl *decl, const AvailabilityRange &platformRange) {
-  PlatformInfo platformAvailability{Info->Platform};
+  PlatformInfo platformAvailability{storage->Platform};
   bool isConstrained = false;
   isConstrained |= platformAvailability.constrainWith(decl);
   isConstrained |= constrainRange(platformAvailability.Range, platformRange);
 
   if (!isConstrained)
     return;
 
-  Info = Storage::get(platformAvailability, decl->getASTContext());
+  storage = Storage::get(platformAvailability, decl->getASTContext());
 }
 
 bool AvailabilityContext::isContainedIn(const AvailabilityContext other) const {
-  if (!Info->Platform.isContainedIn(other.Info->Platform))
+  if (!storage->Platform.isContainedIn(other.storage->Platform))
     return false;
 
   return true;