Sema: Adopt SemanticAvailableAttr in override availability checking.

Author: tshortli

lib/Sema/TypeCheckAvailability.cpp

@@ -2954,11 +2954,11 @@ static bool diagnoseIfDeprecated(SourceLoc loc,
 
 void swift::diagnoseOverrideOfUnavailableDecl(ValueDecl *override,
                                               const ValueDecl *base,
-                                              const AvailableAttr *attr) {
+                                              SemanticAvailableAttr attr) {
   ASTContext &ctx = override->getASTContext();
   auto &diags = ctx.Diags;
-  if (attr->Rename.empty()) {
-    EncodedDiagnosticMessage EncodedMessage(attr->Message);
+  if (attr.getRename().empty()) {
+    EncodedDiagnosticMessage EncodedMessage(attr.getMessage());
     diags.diagnose(override, diag::override_unavailable,
                    override->getBaseName(), EncodedMessage.Message);
 
@@ -2970,7 +2970,7 @@ void swift::diagnoseOverrideOfUnavailableDecl(ValueDecl *override,
   diagnoseExplicitUnavailability(
       base, override->getLoc(), where,
       /*Flags*/ std::nullopt, [&](InFlightDiagnostic &diag) {
-        ParsedDeclName parsedName = parseDeclName(attr->Rename);
+        ParsedDeclName parsedName = parseDeclName(attr.getRename());
         if (!parsedName || parsedName.isPropertyAccessor() ||
             parsedName.isMember() || parsedName.isOperator()) {
           return;

lib/Sema/TypeCheckAvailability.h

@@ -240,7 +240,7 @@ bool diagnoseDeclAvailability(const ValueDecl *D, SourceRange R,
 /// unavailable declaration.
 void diagnoseOverrideOfUnavailableDecl(ValueDecl *override,
                                        const ValueDecl *base,
-                                       const AvailableAttr *attr);
+                                       SemanticAvailableAttr attr);
 
 /// Checks whether a declaration should be considered unavailable when referred
 /// to in the given declaration context and availability context and, if so,

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1919,21 +1919,22 @@ enum class OverrideUnavailabilityStatus {
   Ignored,
 };
 
-static std::pair<OverrideUnavailabilityStatus, const AvailableAttr *>
+static std::pair<OverrideUnavailabilityStatus,
+                 std::optional<SemanticAvailableAttr>>
 checkOverrideUnavailability(ValueDecl *override, ValueDecl *base) {
   if (auto *overrideParent = override->getDeclContext()->getAsDecl()) {
     // If the parent of the override is unavailable, then the unavailability of
     // the override decl is irrelevant.
     if (overrideParent->isSemanticallyUnavailable())
-      return {OverrideUnavailabilityStatus::Ignored, nullptr};
+      return {OverrideUnavailabilityStatus::Ignored, std::nullopt};
   }
 
   if (auto *baseAccessor = dyn_cast<AccessorDecl>(base)) {
     // Ignore implicit accessors since the diagnostics are likely to duplicate
     // the diagnostics for the explicit accessors that availability was inferred
     // from.
     if (baseAccessor->isImplicit())
-      return {OverrideUnavailabilityStatus::Ignored, nullptr};
+      return {OverrideUnavailabilityStatus::Ignored, std::nullopt};
 
     if (auto *overrideAccessor = dyn_cast<AccessorDecl>(override)) {
       // If base and override are accessors, check whether the unavailability of
@@ -1942,18 +1943,17 @@ checkOverrideUnavailability(ValueDecl *override, ValueDecl *base) {
       if (checkOverrideUnavailability(overrideAccessor->getStorage(),
                                       baseAccessor->getStorage())
               .first != OverrideUnavailabilityStatus::Compatible)
-        return {OverrideUnavailabilityStatus::Ignored, nullptr};
+        return {OverrideUnavailabilityStatus::Ignored, std::nullopt};
     }
   }
 
   auto baseUnavailableAttr = base->getUnavailableAttr();
   auto overrideUnavailableAttr = override->getUnavailableAttr();
 
   if (baseUnavailableAttr && !overrideUnavailableAttr)
-    return {OverrideUnavailabilityStatus::BaseUnavailable,
-            baseUnavailableAttr->getParsedAttr()};
+    return {OverrideUnavailabilityStatus::BaseUnavailable, baseUnavailableAttr};
 
-  return {OverrideUnavailabilityStatus::Compatible, nullptr};
+  return {OverrideUnavailabilityStatus::Compatible, std::nullopt};
 }
 
 static bool checkSingleOverride(ValueDecl *override, ValueDecl *base) {
@@ -2226,11 +2226,11 @@ static bool checkSingleOverride(ValueDecl *override, ValueDecl *base) {
   // FIXME: Possibly should extend to more availability checking.
   auto unavailabilityStatusAndAttr =
       checkOverrideUnavailability(override, base);
-  auto *unavailableAttr = unavailabilityStatusAndAttr.second;
+  auto unavailableAttr = unavailabilityStatusAndAttr.second;
 
   switch (unavailabilityStatusAndAttr.first) {
   case OverrideUnavailabilityStatus::BaseUnavailable: {
-    diagnoseOverrideOfUnavailableDecl(override, base, unavailableAttr);
+    diagnoseOverrideOfUnavailableDecl(override, base, unavailableAttr.value());
 
     if (isUnavailableInAllVersions(base)) {
       auto modifier = override->getAttrs().getAttribute<OverrideAttr>();

lib/Sema/TypeCheckProtocol.cpp

@@ -4408,8 +4408,8 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
     }
 
     case CheckKind::Unavailable: {
-      auto *attr = requirement->getUnavailableAttr()->getParsedAttr();
-      diagnoseOverrideOfUnavailableDecl(witness, requirement, attr);
+      diagnoseOverrideOfUnavailableDecl(
+          witness, requirement, requirement->getUnavailableAttr().value());
       break;
     }