Merge pull request swiftlang#78637 from tshortli/remove-domain-storage-from-semantic-available-attr

AST: Remove inline AvailabilityDomain from SemanticAvailableAttr

Author: tshortli

include/swift/AST/Attr.h

@@ -797,6 +797,13 @@ class AvailableAttr : public DeclAttribute {
   /// resolved successfully.
   std::optional<AvailabilityDomain> getCachedDomain() const { return Domain; }
 
+  /// Returns true if the `AvailabilityDomain` associated with the attribute
+  /// has been resolved successfully.
+  bool hasCachedDomain() const {
+    // For now, domains are always set on construction of the attribute.
+    return true;
+  }
+
   /// Returns the kind of availability the attribute specifies.
   Kind getKind() const { return static_cast<Kind>(Bits.AvailableAttr.Kind); }
 
@@ -3189,20 +3196,24 @@ class ParsedDeclAttributes {
   }
 };
 
-/// A wrapper for `AvailableAttr` that is enriched with additional semantic
-/// informaton, like its corresponding `AvailabilityDomain`.
+/// A wrapper for `AvailableAttr` that enriches it with additional semantic
+/// informaton that can only be determined using the `AvailabilityDomain`
+/// associated with the attribute. A `SemanticAvailableAttr` can only be
+/// constructed with an `AvailableAttr` that has a resolved
+/// `AvailabilityDomain`.
 class SemanticAvailableAttr final {
   const AvailableAttr *attr;
-  AvailabilityDomain domain;
 
 public:
-  SemanticAvailableAttr(const AvailableAttr *attr, AvailabilityDomain domain)
-      : attr(attr), domain(domain) {
+  SemanticAvailableAttr(const AvailableAttr *attr) : attr(attr) {
     assert(attr);
+    assert(attr->hasCachedDomain());
   }
 
   const AvailableAttr *getParsedAttr() const { return attr; }
-  const AvailabilityDomain getDomain() const { return domain; }
+  const AvailabilityDomain getDomain() const {
+    return attr->getCachedDomain().value();
+  }
 
   /// The version tuple written in source for the `introduced:` component.
   std::optional<llvm::VersionTuple> getIntroduced() const {
@@ -3640,6 +3651,32 @@ struct EnumTraits<TypeAttrKind> {
 
 } // end namespace swift
 
+namespace llvm {
+using swift::AvailableAttr;
+using swift::SemanticAvailableAttr;
+
+// A SemanticAvailableAttr just wraps an `AvailableAttr *` and is therefore
+// "pointer like".
+template <typename T>
+struct PointerLikeTypeTraits;
+template <>
+struct PointerLikeTypeTraits<SemanticAvailableAttr> {
+public:
+  static inline void *getAsVoidPointer(SemanticAvailableAttr attr) {
+    return reinterpret_cast<void *>(
+        const_cast<AvailableAttr *>(attr.getParsedAttr()));
+  }
+  static inline SemanticAvailableAttr getFromVoidPointer(void *P) {
+    return SemanticAvailableAttr(static_cast<AvailableAttr *>(P));
+  }
+  enum {
+    NumLowBitsAvailable =
+        PointerLikeTypeTraits<AvailableAttr *>::NumLowBitsAvailable
+  };
+};
+
+} // end namespace llvm
+
 #undef UNIMPLEMENTED_CLONE
 
 #endif

lib/AST/Attr.cpp

@@ -918,7 +918,7 @@ ParsedDeclAttrFilter::operator()(const DeclAttribute *Attr) const {
 }
 
 bool SemanticAvailableAttr::isActive(ASTContext &ctx) const {
-  return domain.isActive(ctx);
+  return getDomain().isActive(ctx);
 }
 
 std::optional<SemanticAvailableAttr>

lib/AST/Availability.cpp

@@ -447,9 +447,7 @@ Decl::getSemanticAvailableAttrs(bool includeInactive) const {
 
 std::optional<SemanticAvailableAttr>
 Decl::getSemanticAvailableAttr(const AvailableAttr *attr) const {
-  if (auto domain = attr->getCachedDomain())
-    return SemanticAvailableAttr(attr, *domain);
-  return std::nullopt;
+  return SemanticAvailableAttr(attr);
 }
 
 std::optional<SemanticAvailableAttr>
@@ -790,7 +788,7 @@ bool AvailabilityInference::isAvailableAsSPI(const Decl *D) {
 
 AvailabilityRange
 SemanticAvailableAttr::getIntroducedRange(const ASTContext &Ctx) const {
-  assert(domain.isActive(Ctx));
+  assert(getDomain().isActive(Ctx));
 
   auto *attr = getParsedAttr();
   if (!attr->Introduced.has_value())

lib/Serialization/Serialization.cpp

@@ -3058,9 +3058,8 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
       ENCODE_VER_TUPLE(Obsoleted, theAttr->Obsoleted)
 
       assert(theAttr->Rename.empty() || !theAttr->hasCachedRenamedDecl());
-
+      assert(theAttr->hasCachedDomain());
       auto domain = theAttr->getCachedDomain();
-      assert(domain);
 
       // FIXME: [availability] Serialize domain and kind directly.
       llvm::SmallString<32> blob;