AST: Store unavailability and deprecation status in AvailabilityContext.

Author: tshortli

include/swift/AST/Availability.h

@@ -345,6 +345,18 @@ class AvailabilityContext : public llvm::FoldingSetNode {
     /// The introduction version.
     AvailabilityRange Range;
 
+    /// When `IsUnavailable` is true, this value stores the broadest platform
+    /// kind for which the context is unavailable.
+    PlatformKind UnavailablePlatform;
+
+    /// Whether or not the context is considered unavailable on the current
+    /// platform.
+    unsigned IsUnavailable : 1;
+
+    /// Whether or not the context is considered deprecated on the current
+    /// platform.
+    unsigned IsDeprecated : 1;
+
     /// Sets `Range` to `other` if `other` is more restrictive. Returns true if
     /// any property changed as a result of adding this constraint.
     bool constrainRange(const AvailabilityRange &other) {
@@ -360,8 +372,23 @@ class AvailabilityContext : public llvm::FoldingSetNode {
     /// any property changed as a result of adding this constraint.
     bool constrainRange(const Decl *decl);
 
+    /// Updates `UnavailablePlatform` and `IsUnavailable` to reflect the status
+    /// of `decl` if its platform unavailability is more restrictive. Returns
+    /// true if any property changed as a result of adding this constraint.
+    bool constrainUnavailability(const Decl *decl);
+
+    /// If `decl` is deprecated, sets `IsDeprecated` to true. Returns true if
+    /// any property changed as a result of adding this constraint.
+    bool constrainDeprecated(const Decl *decl);
+
+    /// Returns true if `other` is as available or is more available.
+    bool isContainedIn(const PlatformInfo &other) const;
+
     void Profile(llvm::FoldingSetNodeID &ID) const {
       Range.getRawVersionRange().Profile(ID);
+      ID.AddBoolean(IsUnavailable);
+      ID.AddInteger(static_cast<uint8_t>(UnavailablePlatform));
+      ID.AddBoolean(IsDeprecated);
     }
   };
   PlatformInfo PlatformAvailability;
@@ -381,8 +408,14 @@ class AvailabilityContext : public llvm::FoldingSetNode {
   /// Retrieves a uniqued `AvailabilityContext` with the given platform
   /// availability parameters.
   static const AvailabilityContext *
-  get(const AvailabilityRange &platformAvailability, ASTContext &ctx) {
-    PlatformInfo platformInfo{platformAvailability};
+  get(const AvailabilityRange &platformAvailability,
+      std::optional<PlatformKind> unavailablePlatform, bool deprecated,
+      ASTContext &ctx) {
+    PlatformInfo platformInfo{platformAvailability,
+                              unavailablePlatform.has_value()
+                                  ? *unavailablePlatform
+                                  : PlatformKind::none,
+                              unavailablePlatform.has_value(), deprecated};
     return get(platformInfo, ctx);
   }
 
@@ -392,6 +425,18 @@ class AvailabilityContext : public llvm::FoldingSetNode {
     return PlatformAvailability.Range;
   }
 
+  /// When the context is unavailable on the current platform this returns the
+  /// broadest `PlatformKind` for which the context is unavailable. Otherwise,
+  /// returns `nullopt`.
+  std::optional<PlatformKind> getUnavailablePlatformKind() const {
+    if (PlatformAvailability.IsUnavailable)
+      return PlatformAvailability.UnavailablePlatform;
+    return std::nullopt;
+  }
+
+  /// Returns true if this context is deprecated on the current platform.
+  bool isDeprecated() const { return PlatformAvailability.IsDeprecated; }
+
   /// Returns the unique context that is the result of constraining the current
   /// context's platform availability range with `platformRange`.
   const AvailabilityContext *
@@ -404,6 +449,12 @@ class AvailabilityContext : public llvm::FoldingSetNode {
   const AvailabilityContext *constrainWithDeclAndPlatformRange(
       Decl *decl, const AvailabilityRange &platformRange) const;
 
+  /// Returns true if `other` is as available or is more available.
+  bool isContainedIn(const AvailabilityContext *other) const;
+
+  void print(llvm::raw_ostream &os) const;
+  SWIFT_DEBUG_DUMP;
+
   void Profile(llvm::FoldingSetNodeID &ID) const;
 };
 

lib/AST/Availability.cpp

@@ -71,8 +71,63 @@ bool AvailabilityContext::PlatformInfo::constrainRange(const Decl *decl) {
   return false;
 }
 
+bool AvailabilityContext::PlatformInfo::constrainUnavailability(
+    const Decl *decl) {
+  auto &ctx = decl->getASTContext();
+  auto *attr = decl->getAttrs().getUnavailable(ctx);
+  if (!attr)
+    return false;
+
+  // Check whether the decl's unavailability reason is the same.
+  if (IsUnavailable && UnavailablePlatform == attr->Platform)
+    return false;
+
+  // Check whether the decl's unavailability reason is more specific.
+  if (attr->Platform != PlatformKind::none &&
+      inheritsAvailabilityFromPlatform(attr->Platform, UnavailablePlatform))
+    return false;
+
+  IsUnavailable = true;
+  UnavailablePlatform = attr->Platform;
+  return true;
+}
+
+bool AvailabilityContext::PlatformInfo::constrainDeprecated(const Decl *decl) {
+  auto &ctx = decl->getASTContext();
+  if (IsDeprecated || !decl->getAttrs().isDeprecated(ctx))
+    return false;
+
+  IsDeprecated = true;
+  return true;
+}
+
+bool AvailabilityContext::PlatformInfo::isContainedIn(
+    const PlatformInfo &other) const {
+  if (!Range.isContainedIn(other.Range))
+    return false;
+
+  if (!IsUnavailable && other.IsUnavailable)
+    return false;
+
+  if (IsUnavailable && other.IsUnavailable) {
+    if (UnavailablePlatform != other.UnavailablePlatform &&
+        UnavailablePlatform != PlatformKind::none &&
+        !inheritsAvailabilityFromPlatform(UnavailablePlatform,
+                                          other.UnavailablePlatform))
+      return false;
+  }
+
+  if (!IsDeprecated && other.IsDeprecated)
+    return false;
+
+  return true;
+}
+
 const AvailabilityContext *AvailabilityContext::getDefault(ASTContext &ctx) {
-  PlatformInfo platformInfo{AvailabilityRange::forInliningTarget(ctx)};
+  PlatformInfo platformInfo{AvailabilityRange::forInliningTarget(ctx),
+                            PlatformKind::none,
+                            /*IsUnavailable*/ false,
+                            /*IsDeprecated*/ false};
   return AvailabilityContext::get(platformInfo, ctx);
 }
 
@@ -94,13 +149,45 @@ AvailabilityContext::constrainWithDeclAndPlatformRange(
   bool isConstrained = false;
   isConstrained |= platformAvailability.constrainRange(decl);
   isConstrained |= platformAvailability.constrainRange(platformRange);
+  isConstrained |= platformAvailability.constrainUnavailability(decl);
+  isConstrained |= platformAvailability.constrainDeprecated(decl);
 
   if (!isConstrained)
     return this;
 
   return get(platformAvailability, decl->getASTContext());
 }
 
+bool AvailabilityContext::isContainedIn(
+    const AvailabilityContext *other) const {
+  if (!PlatformAvailability.isContainedIn(other->PlatformAvailability))
+    return false;
+
+  return true;
+}
+
+static std::string
+stringForAvailability(const AvailabilityRange &availability) {
+  if (availability.isAlwaysAvailable())
+    return "all";
+  if (availability.isKnownUnreachable())
+    return "none";
+
+  return availability.getVersionString();
+}
+
+void AvailabilityContext::print(llvm::raw_ostream &os) const {
+  os << "version=" << stringForAvailability(getPlatformRange());
+
+  if (auto unavailablePlatform = getUnavailablePlatformKind())
+    os << " unavailable=" << platformString(*unavailablePlatform);
+
+  if (isDeprecated())
+    os << " deprecated";
+}
+
+void AvailabilityContext::dump() const { print(llvm::errs()); }
+
 void AvailabilityContext::Profile(llvm::FoldingSetNodeID &id) const {
   PlatformAvailability.Profile(id);
 }

lib/AST/TypeRefinementContext.cpp

@@ -36,8 +36,7 @@ TypeRefinementContext::TypeRefinementContext(ASTContext &Ctx, IntroNode Node,
   if (Parent) {
     assert(SrcRange.isValid());
     Parent->addChild(this, Ctx);
-    assert(Info->getPlatformRange().isContainedIn(
-        Parent->getPlatformAvailabilityRange()));
+    assert(Info->isContainedIn(Parent->getAvailabilityContext()));
   }
   Ctx.addDestructorCleanup(Children);
 }
@@ -400,7 +399,8 @@ void TypeRefinementContext::print(raw_ostream &OS, SourceManager &SrcMgr,
   OS.indent(Indent);
   OS << "(" << getReasonName(getReason());
 
-  OS << " version=" << stringForAvailability(getPlatformAvailabilityRange());
+  OS << " ";
+  AvailabilityInfo->print(OS);
 
   if (getReason() == Reason::Decl || getReason() == Reason::DeclImplicit) {
     Decl *D = Node.getAsDecl();
@@ -581,8 +581,8 @@ void TypeRefinementContext::verify(const TypeRefinementContext *parent,
                         {{"child", this}, {"parent", parent}});
   }
 
-  if (!getPlatformAvailabilityRange().isContainedIn(
-          parent->getPlatformAvailabilityRange()))
+  if (!getAvailabilityContext()->isContainedIn(
+          parent->getAvailabilityContext()))
     verificationError(ctx, "child availability range not contained",
                       {{"child", this}, {"parent", parent}});
 }

test/Sema/availability_refinement_contexts.swift

@@ -311,6 +311,33 @@ func testStringInterpolation() {
     """
 }
 
+// CHECK-NEXT: {{^}}  (decl_implicit version=50 unavailable=macOS decl=unavailableOnMacOS()
+// CHECK-NEXT: {{^}}    (decl_implicit version=50 unavailable=macOS decl=x
+
+@available(macOS, unavailable)
+func unavailableOnMacOS() {
+  let x = 1
+}
+
+// CHECK-NEXT: {{^}}  (decl_implicit version=50 deprecated decl=deprecatedOnMacOS()
+// CHECK-NEXT: {{^}}    (decl_implicit version=50 deprecated decl=x
+
+@available(macOS, deprecated)
+func deprecatedOnMacOS() {
+  let x = 1
+}
+
+// CHECK-NEXT: {{^}}  (decl_implicit version=50 decl=extension.SomeEnum
+// CHECK-NEXT: {{^}}    (decl_implicit version=50 unavailable=macOS decl=extension.SomeEnum
+// CHECK-NEXT: {{^}}      (decl_implicit version=50 unavailable=macOS decl=propertyInUnavailableExtension
+// CHECK-NEXT: {{^}}        (decl version=52 unavailable=macOS decl=propertyInUnavailableExtension
+
+@available(macOS, unavailable)
+extension SomeEnum {
+  @available(OSX 52, *)
+  var propertyInUnavailableExtension: Int { 1 }
+}
+
 // CHECK-NEXT: {{^}}  (decl version=51 decl=FinalDecl
 
 @available(OSX 51, *)