Merge pull request swiftlang#79385 from tshortli/availability-domain-or-identifier

AST: Introduce `AvailabilityDomainOrIdentifier`

Author: tshortli

include/swift/AST/ASTBridging.h

@@ -755,18 +755,17 @@ BridgedAvailableAttr BridgedAvailableAttr_createParsed(
     BridgedSourceRange cDeprecatedRange, BridgedVersionTuple cObsoleted,
     BridgedSourceRange cObsoletedRange);
 
-SWIFT_NAME(
-    "BridgedAvailableAttr.createParsed(_:atLoc:range:domainString:domainLoc:kind:message:"
-    "renamed:introduced:introducedRange:deprecated:deprecatedRange:"
-    "obsoleted:obsoletedRange:)")
-BridgedAvailableAttr BridgedAvailableAttr_createParsedStr(
+SWIFT_NAME("BridgedAvailableAttr.createParsed(_:atLoc:range:domainIdentifier:"
+           "domainLoc:kind:message:renamed:introduced:introducedRange:"
+           "deprecated:deprecatedRange:obsoleted:obsoletedRange:)")
+BridgedAvailableAttr BridgedAvailableAttr_createParsedIdentifier(
     BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
-    BridgedSourceRange cRange, BridgedStringRef cDomainString, BridgedSourceLoc cDomainLoc,
-    BridgedAvailableAttrKind cKind, BridgedStringRef cMessage,
-    BridgedStringRef cRenamed, BridgedVersionTuple cIntroduced,
-    BridgedSourceRange cIntroducedRange, BridgedVersionTuple cDeprecated,
-    BridgedSourceRange cDeprecatedRange, BridgedVersionTuple cObsoleted,
-    BridgedSourceRange cObsoletedRange);
+    BridgedSourceRange cRange, BridgedIdentifier cDomainIdentifier,
+    BridgedSourceLoc cDomainLoc, BridgedAvailableAttrKind cKind,
+    BridgedStringRef cMessage, BridgedStringRef cRenamed,
+    BridgedVersionTuple cIntroduced, BridgedSourceRange cIntroducedRange,
+    BridgedVersionTuple cDeprecated, BridgedSourceRange cDeprecatedRange,
+    BridgedVersionTuple cObsoleted, BridgedSourceRange cObsoletedRange);
 
 enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedExecutionKind {
   BridgedExecutionKindConcurrent,

include/swift/AST/Attr.h

@@ -151,13 +151,12 @@ class DeclAttribute : public AttributeBase {
       Value : 32
     );
 
-    SWIFT_INLINE_BITFIELD(AvailableAttr, DeclAttribute, 4+1+1+1+1+1,
+    SWIFT_INLINE_BITFIELD(AvailableAttr, DeclAttribute, 4+1+1+1+1,
       /// An `AvailableAttr::Kind` value.
       Kind : 4,
 
       /// State storage for `SemanticAvailableAttrRequest`.
       HasComputedSemanticAttr : 1,
-      HasDomain : 1,
 
       /// State storage for `RenamedDeclRequest`.
       HasComputedRenamedDecl : 1,
@@ -737,16 +736,8 @@ class AvailableAttr : public DeclAttribute {
     NoAsync,
   };
 
-  AvailableAttr(SourceLoc AtLoc, SourceRange Range, AvailabilityDomain Domain,
-                SourceLoc DomainLoc, Kind Kind, StringRef Message,
-                StringRef Rename, const llvm::VersionTuple &Introduced,
-                SourceRange IntroducedRange,
-                const llvm::VersionTuple &Deprecated,
-                SourceRange DeprecatedRange,
-                const llvm::VersionTuple &Obsoleted, SourceRange ObsoletedRange,
-                bool Implicit, bool IsSPI);
-
-  AvailableAttr(SourceLoc AtLoc, SourceRange Range, StringRef DomainString,
+  AvailableAttr(SourceLoc AtLoc, SourceRange Range,
+                AvailabilityDomainOrIdentifier DomainOrIdentifier,
                 SourceLoc DomainLoc, Kind Kind, StringRef Message,
                 StringRef Rename, const llvm::VersionTuple &Introduced,
                 SourceRange IntroducedRange,
@@ -758,10 +749,7 @@ class AvailableAttr : public DeclAttribute {
 private:
   friend class SemanticAvailableAttr;
 
-  union {
-    AvailabilityDomain Domain;
-    StringRef DomainString;
-  };
+  AvailabilityDomainOrIdentifier DomainOrIdentifier;
   const SourceLoc DomainLoc;
 
   const StringRef Message;
@@ -777,24 +765,20 @@ class AvailableAttr : public DeclAttribute {
 public:
   /// Returns true if the `AvailabilityDomain` associated with the attribute
   /// has been resolved successfully.
-  bool hasCachedDomain() const { return Bits.AvailableAttr.HasDomain; }
+  bool hasCachedDomain() const { return DomainOrIdentifier.isDomain(); }
 
   /// Returns the `AvailabilityDomain` associated with the attribute, or
   /// `std::nullopt` if it has either not yet been resolved or could not be
   /// resolved successfully.
   std::optional<AvailabilityDomain> getCachedDomain() const {
-    if (hasCachedDomain())
-      return Domain;
-    return std::nullopt;
+    return DomainOrIdentifier.getAsDomain();
   }
 
   /// If the attribute does not already have a cached `AvailabilityDomain`, this
-  /// returns the domain string that was written in source, from which an
+  /// returns the domain identifier that was written in source, from which an
   /// `AvailabilityDomain` can be resolved.
-  std::optional<StringRef> getDomainString() const {
-    if (hasCachedDomain())
-      return std::nullopt;
-    return DomainString;
+  std::optional<Identifier> getDomainIdentifier() const {
+    return DomainOrIdentifier.getAsIdentifier();
   }
 
   SourceLoc getDomainLoc() const { return DomainLoc; }
@@ -919,9 +903,8 @@ class AvailableAttr : public DeclAttribute {
   void setRawObsoleted(llvm::VersionTuple version) { Obsoleted = version; }
 
   void setCachedDomain(AvailabilityDomain domain) {
-    assert(!Bits.AvailableAttr.HasDomain);
-    Domain = domain;
-    Bits.AvailableAttr.HasDomain = true;
+    assert(!DomainOrIdentifier.isDomain());
+    DomainOrIdentifier.setDomain(domain);
   }
 
   bool hasComputedSemanticAttr() const {

include/swift/AST/AvailabilityDomain.h

@@ -277,6 +277,40 @@ class CustomAvailabilityDomain : public ASTAllocated<CustomAvailabilityDomain> {
   ModuleDecl *getModule() const { return mod; }
 };
 
+/// Represents either a resolved availability domain or an identifier written
+/// in source that has not yet been resolved to a domain.
+class AvailabilityDomainOrIdentifier {
+  using Storage = llvm::PointerUnion<AvailabilityDomain, Identifier>;
+  Storage storage;
+
+public:
+  AvailabilityDomainOrIdentifier(Identifier identifier)
+      : storage(identifier) {};
+  AvailabilityDomainOrIdentifier(AvailabilityDomain domain)
+      : storage(domain) {};
+
+  bool isDomain() const { return storage.is<AvailabilityDomain>(); }
+  bool isIdentifier() const { return storage.is<Identifier>(); }
+
+  /// Overwrites the existing domain or identifier with the given domain.
+  void setDomain(AvailabilityDomain domain) { storage = Storage(domain); }
+
+  /// Returns the resolved domain, or `std::nullopt` if there isn't one.
+  std::optional<AvailabilityDomain> getAsDomain() const {
+    if (isDomain())
+      return storage.get<AvailabilityDomain>();
+    return std::nullopt;
+  }
+
+  /// Returns the unresolved identifier, or `std::nullopt` if the domain has
+  /// been resolved.
+  std::optional<Identifier> getAsIdentifier() const {
+    if (isIdentifier())
+      return storage.get<Identifier>();
+    return std::nullopt;
+  }
+};
+
 } // end namespace swift
 
 namespace llvm {

lib/AST/ASTDumper.cpp

@@ -4965,7 +4965,8 @@ class PrintAttribute : public AttributeVisitor<PrintAttribute, void, Label>,
       printField(domain->getNameForAttributePrinting(),
                  Label::always("domain"));
     } else {
-      printField(*Attr->getDomainString(), Label::always("domainString"));
+      printField(*Attr->getDomainIdentifier(),
+                 Label::always("domainIdentifier"));
     }
 
     switch (Attr->getKind()) {

lib/AST/Attr.cpp

@@ -2126,34 +2126,19 @@ Type RawLayoutAttr::getResolvedCountType(StructDecl *sd) const {
 }
 
 AvailableAttr::AvailableAttr(
-    SourceLoc AtLoc, SourceRange Range, AvailabilityDomain Domain,
-    SourceLoc DomainLoc, Kind Kind, StringRef Message, StringRef Rename,
+    SourceLoc AtLoc, SourceRange Range,
+    AvailabilityDomainOrIdentifier DomainOrIdentifier, SourceLoc DomainLoc,
+    Kind Kind, StringRef Message, StringRef Rename,
     const llvm::VersionTuple &Introduced, SourceRange IntroducedRange,
     const llvm::VersionTuple &Deprecated, SourceRange DeprecatedRange,
     const llvm::VersionTuple &Obsoleted, SourceRange ObsoletedRange,
     bool Implicit, bool IsSPI)
     : DeclAttribute(DeclAttrKind::Available, AtLoc, Range, Implicit),
-      Domain(Domain), DomainLoc(DomainLoc), Message(Message), Rename(Rename),
-      Introduced(Introduced), IntroducedRange(IntroducedRange),
-      Deprecated(Deprecated), DeprecatedRange(DeprecatedRange),
-      Obsoleted(Obsoleted), ObsoletedRange(ObsoletedRange) {
-  Bits.AvailableAttr.Kind = static_cast<uint8_t>(Kind);
-  Bits.AvailableAttr.HasDomain = true;
-  Bits.AvailableAttr.IsSPI = IsSPI;
-}
-
-AvailableAttr::AvailableAttr(
-    SourceLoc AtLoc, SourceRange Range, StringRef DomainString,
-    SourceLoc DomainLoc, Kind Kind, StringRef Message, StringRef Rename,
-    const llvm::VersionTuple &Introduced, SourceRange IntroducedRange,
-    const llvm::VersionTuple &Deprecated, SourceRange DeprecatedRange,
-    const llvm::VersionTuple &Obsoleted, SourceRange ObsoletedRange,
-    bool Implicit, bool IsSPI)
-    : DeclAttribute(DeclAttrKind::Available, AtLoc, Range, Implicit),
-      DomainString(DomainString), DomainLoc(DomainLoc), Message(Message),
-      Rename(Rename), Introduced(Introduced), IntroducedRange(IntroducedRange),
-      Deprecated(Deprecated), DeprecatedRange(DeprecatedRange),
-      Obsoleted(Obsoleted), ObsoletedRange(ObsoletedRange) {
+      DomainOrIdentifier(DomainOrIdentifier), DomainLoc(DomainLoc),
+      Message(Message), Rename(Rename), Introduced(Introduced),
+      IntroducedRange(IntroducedRange), Deprecated(Deprecated),
+      DeprecatedRange(DeprecatedRange), Obsoleted(Obsoleted),
+      ObsoletedRange(ObsoletedRange) {
   Bits.AvailableAttr.Kind = static_cast<uint8_t>(Kind);
   Bits.AvailableAttr.IsSPI = IsSPI;
 }
@@ -2225,9 +2210,9 @@ bool BackDeployedAttr::isActivePlatform(const ASTContext &ctx,
 AvailableAttr *AvailableAttr::clone(ASTContext &C, bool implicit) const {
   return new (C) AvailableAttr(
       implicit ? SourceLoc() : AtLoc, implicit ? SourceRange() : getRange(),
-      Domain, implicit ? SourceLoc() : DomainLoc, getKind(), Message, Rename,
-      Introduced, implicit ? SourceRange() : IntroducedRange, Deprecated,
-      implicit ? SourceRange() : DeprecatedRange, Obsoleted,
+      DomainOrIdentifier, implicit ? SourceLoc() : DomainLoc, getKind(),
+      Message, Rename, Introduced, implicit ? SourceRange() : IntroducedRange,
+      Deprecated, implicit ? SourceRange() : DeprecatedRange, Obsoleted,
       implicit ? SourceRange() : ObsoletedRange, implicit, isSPI());
 }
 

lib/AST/Bridging/DeclAttributeBridging.cpp

@@ -106,17 +106,18 @@ BridgedAvailableAttr BridgedAvailableAttr_createParsed(
                     /*IsSPI=*/false);
 }
 
-BridgedAvailableAttr BridgedAvailableAttr_createParsedStr(
+BridgedAvailableAttr BridgedAvailableAttr_createParsedIdentifier(
     BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
-    BridgedSourceRange cRange, BridgedStringRef cDomainString,
+    BridgedSourceRange cRange, BridgedIdentifier cDomainIdentifier,
     BridgedSourceLoc cDomainLoc, BridgedAvailableAttrKind cKind,
     BridgedStringRef cMessage, BridgedStringRef cRenamed,
     BridgedVersionTuple cIntroduced, BridgedSourceRange cIntroducedRange,
     BridgedVersionTuple cDeprecated, BridgedSourceRange cDeprecatedRange,
     BridgedVersionTuple cObsoleted, BridgedSourceRange cObsoletedRange) {
+
   return new (cContext.unbridged())
       AvailableAttr(cAtLoc.unbridged(), cRange.unbridged(),
-                    cDomainString.unbridged(), cDomainLoc.unbridged(),
+                    cDomainIdentifier.unbridged(), cDomainLoc.unbridged(),
                     unbridge(cKind), cMessage.unbridged(), cRenamed.unbridged(),
                     cIntroduced.unbridged(), cIntroducedRange.unbridged(),
                     cDeprecated.unbridged(), cDeprecatedRange.unbridged(),

lib/ASTGen/Sources/ASTGen/Availability.swift

@@ -234,7 +234,7 @@ extension ASTGenVisitor {
       self.ctx,
       atLoc: atLoc,
       range: range,
-      domainString: platformStr.bridged,
+      domainIdentifier: self.ctx.getIdentifier(platformStr.bridged),
       domainLoc: platformLoc,
       kind: attrKind,
       message: message ?? BridgedStringRef(),

lib/Parse/ParseDecl.cpp

@@ -548,9 +548,10 @@ ParserResult<AvailableAttr> Parser::parseExtendedAvailabilitySpecList(
     return nullptr;
 
   auto Attr = new (Context) AvailableAttr(
-      AtLoc, SourceRange(AttrLoc, Tok.getLoc()), Platform, PlatformLoc,
-      AttrKind, Message, Renamed, Introduced.Version, Introduced.Range,
-      Deprecated.Version, Deprecated.Range, Obsoleted.Version, Obsoleted.Range,
+      AtLoc, SourceRange(AttrLoc, Tok.getLoc()),
+      Context.getIdentifier(Platform), PlatformLoc, AttrKind, Message, Renamed,
+      Introduced.Version, Introduced.Range, Deprecated.Version,
+      Deprecated.Range, Obsoleted.Version, Obsoleted.Range,
       /*Implicit=*/false, AttrName == SPI_AVAILABLE_ATTRNAME);
   return makeParserResult(Attr);
 

lib/Sema/TypeCheckAttr.cpp

@@ -8326,13 +8326,13 @@ ValueDecl *RenamedDeclRequest::evaluate(Evaluator &evaluator,
 }
 
 static std::optional<AvailabilityDomain>
-getAvailabilityDomainForName(StringRef name, const DeclContext *declContext) {
-  if (auto builtinDomain =
-          AvailabilityDomain::builtinDomainForString(name, declContext))
+getAvailabilityDomainForName(Identifier identifier,
+                             const DeclContext *declContext) {
+  if (auto builtinDomain = AvailabilityDomain::builtinDomainForString(
+          identifier.str(), declContext))
     return builtinDomain;
 
   auto &ctx = declContext->getASTContext();
-  auto identifier = ctx.getIdentifier(name);
   if (auto customDomain =
           ctx.MainModule->getAvailabilityDomainForIdentifier(identifier))
     return customDomain;
@@ -8359,22 +8359,23 @@ SemanticAvailableAttrRequest::evaluate(swift::Evaluator &evaluator,
   auto domain = attr->getCachedDomain();
 
   if (!domain) {
-    auto domainName = attr->getDomainString();
-    ASSERT(domainName);
+    auto domainIdentifier = attr->getDomainIdentifier();
+    ASSERT(domainIdentifier);
 
     // Attempt to resolve the domain specified for the attribute and diagnose
     // if no domain is found.
     auto declContext = decl->getInnermostDeclContext();
-    domain = getAvailabilityDomainForName(*domainName, declContext);
+    domain = getAvailabilityDomainForName(*domainIdentifier, declContext);
     if (!domain) {
-      if (auto suggestion = closestCorrectedPlatformString(*domainName)) {
+      auto domainString = domainIdentifier->str();
+      if (auto suggestion = closestCorrectedPlatformString(domainString)) {
         diags
             .diagnose(domainLoc, diag::attr_availability_suggest_platform,
-                      *domainName, attrName, *suggestion)
+                      domainString, attrName, *suggestion)
             .fixItReplace(SourceRange(domainLoc), *suggestion);
       } else {
         diags.diagnose(attrLoc, diag::attr_availability_unknown_platform,
-                       *domainName, attrName);
+                       domainString, attrName);
       }
       return std::nullopt;
     }
@@ -8384,7 +8385,7 @@ SemanticAvailableAttrRequest::evaluate(swift::Evaluator &evaluator,
         !declContext->isInSwiftinterface()) {
       diags.diagnose(domainLoc,
                      diag::attr_availability_requires_custom_availability,
-                     *domainName, attr);
+                     domain->getNameForAttributePrinting(), attr);
       return std::nullopt;
     }