AST: Rename SemanticDeclAvailability to DeclRuntimeAvailability.

Author: tshortli

include/swift/AST/TypeCheckRequests.h

@@ -4134,7 +4134,7 @@ class RenamedDeclRequest
 ///
 /// The elements of this enumeration must be ordered from most available to
 /// least available.
-enum class SemanticDeclAvailability : uint8_t {
+enum class DeclRuntimeAvailability : uint8_t {
   /// The decl is potentially available at runtime. If it is unavailable at
   /// compile time in the current module, it may still be considered available
   /// at compile time by other modules with different settings. For example, a
@@ -4155,18 +4155,18 @@ enum class SemanticDeclAvailability : uint8_t {
   AlwaysUnavailableABICompatible,
 };
 
-class SemanticDeclAvailabilityRequest
-    : public SimpleRequest<SemanticDeclAvailabilityRequest,
-                           SemanticDeclAvailability(const Decl *decl),
+class DeclRuntimeAvailabilityRequest
+    : public SimpleRequest<DeclRuntimeAvailabilityRequest,
+                           DeclRuntimeAvailability(const Decl *decl),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  SemanticDeclAvailability evaluate(Evaluator &evaluator,
-                                    const Decl *decl) const;
+  DeclRuntimeAvailability evaluate(Evaluator &evaluator,
+                                   const Decl *decl) const;
 
 public:
   bool isCached() const { return true; }

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -473,8 +473,8 @@ SWIFT_REQUEST(TypeChecker, ImplicitKnownProtocolConformanceRequest,
 SWIFT_REQUEST(TypeChecker, RenamedDeclRequest,
               ValueDecl *(const ValueDecl *, const AvailableAttr *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, SemanticDeclAvailabilityRequest,
-              SemanticDeclAvailability(const Decl *),
+SWIFT_REQUEST(TypeChecker, DeclRuntimeAvailabilityRequest,
+              DeclRuntimeAvailability(const Decl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ClosureEffectsRequest,
               FunctionType::ExtInfo(ClosureExpr *),

lib/AST/Availability.cpp

@@ -572,15 +572,15 @@ static bool constraintIndicatesRuntimeUnavailability(
   }
 }
 
-/// Computes the `SemanticDeclAvailability` value for `decl`.
-static SemanticDeclAvailability getSemanticDeclAvailability(const Decl *decl) {
+/// Computes the `DeclRuntimeAvailability` value for `decl`.
+static DeclRuntimeAvailability getDeclRuntimeAvailability(const Decl *decl) {
   // Don't trust unavailability on declarations from Clang modules.
   if (isa<ClangModuleUnit>(decl->getDeclContext()->getModuleScopeContext()))
-    return SemanticDeclAvailability::PotentiallyAvailable;
+    return DeclRuntimeAvailability::PotentiallyAvailable;
 
   // Check whether the decl is unavailable at all.
   if (!decl->isUnavailable())
-    return SemanticDeclAvailability::PotentiallyAvailable;
+    return DeclRuntimeAvailability::PotentiallyAvailable;
 
   auto &ctx = decl->getASTContext();
   auto compatibilityDomains = availabilityDomainsForABICompatibility(ctx);
@@ -624,37 +624,37 @@ static SemanticDeclAvailability getSemanticDeclAvailability(const Decl *decl) {
 
     // Either every compatibility domain has been proven unavailable or this
     // constraint proves runtime unavailability on its own.
-    return SemanticDeclAvailability::AlwaysUnavailableABICompatible;
+    return DeclRuntimeAvailability::AlwaysUnavailableABICompatible;
   }
 
-  return SemanticDeclAvailability::PotentiallyAvailable;
+  return DeclRuntimeAvailability::PotentiallyAvailable;
 }
 
-SemanticDeclAvailability
-SemanticDeclAvailabilityRequest::evaluate(Evaluator &evaluator,
-                                          const Decl *decl) const {
-  auto inherited = SemanticDeclAvailability::PotentiallyAvailable;
+DeclRuntimeAvailability
+DeclRuntimeAvailabilityRequest::evaluate(Evaluator &evaluator,
+                                         const Decl *decl) const {
+  auto inherited = DeclRuntimeAvailability::PotentiallyAvailable;
   if (auto *parent =
           AvailabilityInference::parentDeclForInferredAvailability(decl)) {
     inherited = evaluateOrDefault(
-        evaluator, SemanticDeclAvailabilityRequest{parent}, inherited);
+        evaluator, DeclRuntimeAvailabilityRequest{parent}, inherited);
   }
 
   // If the inherited semantic availability is already maximally unavailable
   // then skip computing unavailability for this declaration.
-  if (inherited == SemanticDeclAvailability::AlwaysUnavailableABICompatible)
-    return SemanticDeclAvailability::AlwaysUnavailableABICompatible;
+  if (inherited == DeclRuntimeAvailability::AlwaysUnavailableABICompatible)
+    return DeclRuntimeAvailability::AlwaysUnavailableABICompatible;
 
-  auto availability = getSemanticDeclAvailability(decl);
+  auto availability = getDeclRuntimeAvailability(decl);
   return std::max(inherited, availability);
 }
 
 bool Decl::isUnreachableAtRuntime() const {
   auto availability = evaluateOrDefault(
-      getASTContext().evaluator, SemanticDeclAvailabilityRequest{this},
-      SemanticDeclAvailability::PotentiallyAvailable);
+      getASTContext().evaluator, DeclRuntimeAvailabilityRequest{this},
+      DeclRuntimeAvailability::PotentiallyAvailable);
   return availability ==
-         SemanticDeclAvailability::AlwaysUnavailableABICompatible;
+         DeclRuntimeAvailability::AlwaysUnavailableABICompatible;
 }
 
 static UnavailableDeclOptimization