AST: Adopt new AvailableAttr constructor in attribute inference.

Author: tshortli

include/swift/AST/Attr.h

@@ -836,6 +836,23 @@ class AvailableAttr : public DeclAttribute {
         Bits.AvailableAttr.PlatformAgnostic);
   }
 
+  /// Returns the kind of availability the attribute specifies.
+  Kind getKind() const {
+    switch (getPlatformAgnosticAvailability()) {
+    case PlatformAgnosticAvailabilityKind::None:
+    case PlatformAgnosticAvailabilityKind::SwiftVersionSpecific:
+    case PlatformAgnosticAvailabilityKind::PackageDescriptionVersionSpecific:
+      return Kind::Default;
+    case PlatformAgnosticAvailabilityKind::Deprecated:
+      return Kind::Deprecated;
+    case PlatformAgnosticAvailabilityKind::UnavailableInSwift:
+    case PlatformAgnosticAvailabilityKind::Unavailable:
+      return Kind::Unavailable;
+    case PlatformAgnosticAvailabilityKind::NoAsync:
+      return Kind::NoAsync;
+    }
+  }
+
   /// Create an `AvailableAttr` that specifies universal unavailability, e.g.
   /// `@available(*, unavailable)`.
   static AvailableAttr *createUniversallyUnavailable(ASTContext &C,

lib/AST/Availability.cpp

@@ -109,8 +109,7 @@ namespace {
 /// The inferred availability required to access a group of declarations
 /// on a single platform.
 struct InferredAvailability {
-  PlatformAgnosticAvailabilityKind PlatformAgnostic
-    = PlatformAgnosticAvailabilityKind::None;
+  AvailableAttr::Kind Kind = AvailableAttr::Kind::Default;
 
   std::optional<llvm::VersionTuple> Introduced;
   std::optional<llvm::VersionTuple> Deprecated;
@@ -148,10 +147,9 @@ mergeIntoInferredVersion(const std::optional<llvm::VersionTuple> &Version,
 static void mergeWithInferredAvailability(SemanticAvailableAttr Attr,
                                           InferredAvailability &Inferred) {
   auto *ParsedAttr = Attr.getParsedAttr();
-  Inferred.PlatformAgnostic = static_cast<PlatformAgnosticAvailabilityKind>(
-      std::max(static_cast<unsigned>(Inferred.PlatformAgnostic),
-               static_cast<unsigned>(
-                   ParsedAttr->getPlatformAgnosticAvailability())));
+  Inferred.Kind = static_cast<AvailableAttr::Kind>(
+      std::max(static_cast<unsigned>(Inferred.Kind),
+               static_cast<unsigned>(ParsedAttr->getKind())));
 
   // The merge of two introduction versions is the maximum of the two versions.
   if (mergeIntoInferredVersion(Attr.getIntroduced(), Inferred.Introduced,
@@ -164,19 +162,18 @@ static void mergeWithInferredAvailability(SemanticAvailableAttr Attr,
   mergeIntoInferredVersion(Attr.getObsoleted(), Inferred.Obsoleted, std::min);
 }
 
-/// Create an implicit availability attribute for the given platform
+/// Create an implicit availability attribute for the given domain
 /// and with the inferred availability.
-static AvailableAttr *createAvailableAttr(PlatformKind Platform,
+static AvailableAttr *createAvailableAttr(AvailabilityDomain Domain,
                                           const InferredAvailability &Inferred,
-                                          StringRef Message, 
-                                          StringRef Rename,
+                                          StringRef Message, StringRef Rename,
                                           ValueDecl *RenameDecl,
                                           ASTContext &Context) {
   // If there is no information that would go into the availability attribute,
   // don't create one.
-  if (Inferred.PlatformAgnostic == PlatformAgnosticAvailabilityKind::None &&
-      !Inferred.Introduced && !Inferred.Deprecated && !Inferred.Obsoleted &&
-      Message.empty() && Rename.empty() && !RenameDecl)
+  if (Inferred.Kind == AvailableAttr::Kind::Default && !Inferred.Introduced &&
+      !Inferred.Deprecated && !Inferred.Obsoleted && Message.empty() &&
+      Rename.empty() && !RenameDecl)
     return nullptr;
 
   llvm::VersionTuple Introduced =
@@ -186,11 +183,10 @@ static AvailableAttr *createAvailableAttr(PlatformKind Platform,
   llvm::VersionTuple Obsoleted =
       Inferred.Obsoleted.value_or(llvm::VersionTuple());
 
-  return new (Context)
-      AvailableAttr(SourceLoc(), SourceRange(), Platform, Message, Rename,
-                    Introduced, SourceRange(), Deprecated, SourceRange(),
-                    Obsoleted, SourceRange(), Inferred.PlatformAgnostic,
-                    /*Implicit=*/true, Inferred.IsSPI);
+  return new (Context) AvailableAttr(
+      SourceLoc(), SourceRange(), Domain, Inferred.Kind, Message, Rename,
+      Introduced, SourceRange(), Deprecated, SourceRange(), Obsoleted,
+      SourceRange(), /*Implicit=*/true, Inferred.IsSPI);
 }
 
 void AvailabilityInference::applyInferredAvailableAttrs(
@@ -214,8 +210,7 @@ void AvailabilityInference::applyInferredAvailableAttrs(
     do {
       llvm::SmallVector<SemanticAvailableAttr, 8> PendingAttrs;
 
-      for (auto AvAttr :
-           D->getSemanticAvailableAttrs()) {
+      for (auto AvAttr : D->getSemanticAvailableAttrs()) {
         // Skip an attribute from an outer declaration if it is for a platform
         // that was already handled implicitly by an attribute from an inner
         // declaration.
@@ -250,8 +245,12 @@ void AvailabilityInference::applyInferredAvailableAttrs(
   // Create an availability attribute for each observed platform and add
   // to ToDecl.
   for (auto &Pair : Inferred) {
-    auto *Attr = createAvailableAttr(Pair.first, Pair.second, Message,
-                                     Rename, RenameDecl, Context);
+    auto Domain = (Pair.first == PlatformKind::none)
+                      ? AvailabilityDomain::forUniversal()
+                      : AvailabilityDomain::forPlatform(Pair.first);
+
+    auto *Attr = createAvailableAttr(Domain, Pair.second, Message, Rename,
+                                     RenameDecl, Context);
 
     if (Attr) {
       if (RenameDecl && ToValueDecl)