AST: Use AvailabilityDomainOrIdentifier to store domains in AvailabilitySpec.

tshortli · tshortli · commit c54825b4c359 · 2025-02-25T09:02:47.000-08:00
diff --git a/include/swift/AST/ASTBridging.h b/include/swift/AST/ASTBridging.h
@@ -705,25 +705,20 @@ BridgedAvailabilitySpec
 BridgedAvailabilitySpec_createWildcard(BridgedASTContext cContext,
                                        BridgedSourceLoc cLoc);
 
-SWIFT_NAME(
-    "BridgedAvailabilitySpec.createPlatformAgnostic(_:kind:nameLoc:version:"
-    "versionRange:)")
-BridgedAvailabilitySpec BridgedAvailabilitySpec_createPlatformAgnostic(
-    BridgedASTContext cContext, BridgedAvailabilitySpecKind cKind,
+SWIFT_NAME("BridgedAvailabilitySpec.create(_:domain:nameLoc:version:"
+           "versionRange:)")
+BridgedAvailabilitySpec BridgedAvailabilitySpec_createForDomain(
+    BridgedASTContext cContext, BridgedAvailabilityDomain cDomain,
     BridgedSourceLoc cLoc, BridgedVersionTuple cVersion,
     BridgedSourceRange cVersionRange);
 
-SWIFT_NAME("BridgedAvailabilitySpec.createPlatformVersioned(_:platform:"
-           "platformLoc:version:versionRange:)")
-BridgedAvailabilitySpec BridgedAvailabilitySpec_createPlatformVersioned(
-    BridgedASTContext cContext, BridgedPlatformKind cPlatform,
-    BridgedSourceLoc cPlatformLoc, BridgedVersionTuple cVersion,
-    BridgedSourceRange cVersionSrcRange);
-
 SWIFT_NAME("getter:BridgedAvailabilitySpec.sourceRange(self:)")
 BridgedSourceRange
 BridgedAvailabilitySpec_getSourceRange(BridgedAvailabilitySpec spec);
 
+SWIFT_NAME("getter:BridgedAvailabilitySpec.isWildcard(self:)")
+bool BridgedAvailabilitySpec_isWildcard(BridgedAvailabilitySpec spec);
+
 SWIFT_NAME("getter:BridgedAvailabilitySpec.domain(self:)")
 BridgedAvailabilityDomain
 BridgedAvailabilitySpec_getDomain(BridgedAvailabilitySpec spec);
diff --git a/include/swift/AST/AvailabilityDomain.h b/include/swift/AST/AvailabilityDomain.h
@@ -247,6 +247,11 @@ class AvailabilityDomain final {
   void Profile(llvm::FoldingSetNodeID &ID) const {
     ID.AddPointer(getOpaqueValue());
   }
+
+private:
+  friend class AvailabilityDomainOrIdentifier;
+
+  AvailabilityDomain copy(ASTContext &ctx) const;
 };
 
 /// Represents an availability domain that has been defined in a module.
@@ -317,6 +322,11 @@ class AvailabilityDomainOrIdentifier {
       return storage.get<Identifier>();
     return std::nullopt;
   }
+
+  /// Creates a new `AvailabilityDomainOrIdentifier`, defensively copying
+  /// members of the original into the given `ASTContext` in case it is
+  /// different than the context that the original was created for.
+  AvailabilityDomainOrIdentifier copy(ASTContext &ctx) const;
 };
 
 } // end namespace swift
diff --git a/include/swift/AST/AvailabilitySpec.h b/include/swift/AST/AvailabilitySpec.h
@@ -30,32 +30,13 @@
 
 namespace swift {
 class ASTContext;
-
-enum class AvailabilitySpecKind {
-  /// A platform-version constraint of the form "PlatformName X.Y.Z"
-  PlatformVersionConstraint,
-
-  /// A wildcard constraint, spelled '*', that is equivalent
-  /// to CurrentPlatformName >= MinimumDeploymentTargetVersion
-  Wildcard,
-
-  /// A language-version constraint of the form "swift X.Y.Z"
-  LanguageVersionConstraint,
-
-  /// A PackageDescription version constraint of the form "_PackageDescription
-  /// X.Y.Z"
-  PackageDescriptionVersionConstraint,
-};
-
 class SemanticAvailabilitySpec;
 
 /// The root class for specifications of API availability in availability
 /// queries.
 class AvailabilitySpec : public ASTAllocated<AvailabilitySpec> {
-protected:
-  AvailabilitySpecKind Kind;
-
-  std::optional<AvailabilityDomain> Domain;
+  using DomainStorage = llvm::PointerIntPair<AvailabilityDomainOrIdentifier, 1>;
+  DomainStorage Storage;
 
   /// The range of the entire spec, including the version if there is one.
   SourceRange SrcRange;
@@ -70,13 +51,15 @@ class AvailabilitySpec : public ASTAllocated<AvailabilitySpec> {
   // Location of the availability macro expanded to create this spec.
   SourceLoc MacroLoc;
 
-  AvailabilitySpec(AvailabilitySpecKind Kind,
-                   std::optional<AvailabilityDomain> Domain,
-                   SourceRange SrcRange, llvm::VersionTuple Version,
-                   SourceLoc VersionStartLoc)
-      : Kind(Kind), Domain(Domain), SrcRange(SrcRange), Version(Version),
+  AvailabilitySpec(DomainStorage Storage, SourceRange SrcRange,
+                   llvm::VersionTuple Version, SourceLoc VersionStartLoc)
+      : Storage(Storage), SrcRange(SrcRange), Version(Version),
         VersionStartLoc(VersionStartLoc) {}
 
+  AvailabilityDomainOrIdentifier getDomainOrIdentifier() const {
+    return Storage.getPointer();
+  }
+
 public:
   /// Creates a wildcard availability specification that guards execution
   /// by checking that the run-time version is greater than the minimum
@@ -89,33 +72,20 @@ class AvailabilitySpec : public ASTAllocated<AvailabilitySpec> {
   /// compiler will still catch references to potentially unavailable symbols.
   static AvailabilitySpec *createWildcard(ASTContext &ctx, SourceLoc starLoc);
 
-  /// Creates an availability specification that guards execution based on the
-  /// compile-time platform agnostic version, e.g., swift >= 3.0.1,
-  /// package-description >= 4.0.
-  static AvailabilitySpec *createPlatformAgnostic(ASTContext &ctx,
-                                                  AvailabilitySpecKind kind,
-                                                  SourceLoc nameLoc,
+  /// Creates an availability specification that requires a minimum version of
+  /// some availability domain, e.g., macOS >= 10.10 or swift >= 3.0.1.
+  static AvailabilitySpec *
+  createForDomain(ASTContext &ctx, AvailabilityDomain domain, SourceLoc loc,
+                  llvm::VersionTuple version, SourceRange versionRange);
+
+  /// Creates an availability specification for an unknown availability domain.
+  static AvailabilitySpec *createForUnknownDomain(ASTContext &ctx,
+                                                  Identifier domainIdentifier,
+                                                  SourceLoc loc,
                                                   llvm::VersionTuple version,
                                                   SourceRange versionRange);
 
-  /// Creates an availability specification that guards execution based on the
-  /// run-time platform and version, e.g., macOS >= 10.10.
-  static AvailabilitySpec *createPlatformVersioned(ASTContext &ctx,
-                                                   PlatformKind platform,
-                                                   SourceLoc platformLoc,
-                                                   llvm::VersionTuple version,
-                                                   SourceRange versionRange);
-
-  AvailabilitySpec *clone(ASTContext &ctx) const {
-    return new (ctx)
-        AvailabilitySpec(Kind, Domain, SrcRange, Version, VersionStartLoc);
-  }
-
-  AvailabilitySpecKind getKind() const { return Kind; }
-
-  bool isWildcard() const {
-    return getKind() == AvailabilitySpecKind::Wildcard;
-  }
+  AvailabilitySpec *clone(ASTContext &ctx) const;
 
   /// Returns a type-checked representation of the spec, or `std::nullopt` if
   /// the spec is invalid.
@@ -125,7 +95,15 @@ class AvailabilitySpec : public ASTAllocated<AvailabilitySpec> {
   SourceRange getSourceRange() const { return SrcRange; }
   SourceLoc getStartLoc() const { return SrcRange.Start; }
 
-  std::optional<AvailabilityDomain> getDomain() const { return Domain; }
+  bool isWildcard() const {
+    if (auto domain = getDomain())
+      return domain->isUniversal();
+    return false;
+  }
+
+  std::optional<AvailabilityDomain> getDomain() const {
+    return getDomainOrIdentifier().getAsDomain();
+  }
 
   PlatformKind getPlatform() const {
     if (auto domain = getDomain())
diff --git a/lib/AST/AvailabilityDomain.cpp b/lib/AST/AvailabilityDomain.cpp
@@ -168,6 +168,22 @@ AvailabilityDomain AvailabilityDomain::getABICompatibilityDomain() const {
   return *this;
 }
 
+AvailabilityDomain AvailabilityDomain::copy(ASTContext &ctx) const {
+  switch (getKind()) {
+  case Kind::Universal:
+  case Kind::SwiftLanguage:
+  case Kind::PackageDescription:
+  case Kind::Embedded:
+  case Kind::Platform:
+    // These domain kinds aren't ASTContext dependent.
+    return *this;
+  case Kind::Custom:
+    // To support this, the CustomAvailabilityDomain content would need to
+    // be copied to the other context, allocating new storage if necessary.
+    llvm::report_fatal_error("unsupported");
+  }
+}
+
 CustomAvailabilityDomain::CustomAvailabilityDomain(Identifier name,
                                                    ModuleDecl *mod, Kind kind)
     : name(name), kind(kind), mod(mod) {
@@ -180,3 +196,12 @@ CustomAvailabilityDomain::create(const ASTContext &ctx, StringRef name,
                                  ModuleDecl *mod, Kind kind) {
   return new (ctx) CustomAvailabilityDomain(ctx.getIdentifier(name), mod, kind);
 }
+
+AvailabilityDomainOrIdentifier
+AvailabilityDomainOrIdentifier::copy(ASTContext &ctx) const {
+  if (auto identifier = getAsIdentifier())
+    return ctx.getIdentifier(identifier->str());
+
+  DEBUG_ASSERT(isDomain());
+  return getAsDomain()->copy(ctx);
+}
diff --git a/lib/AST/AvailabilitySpec.cpp b/lib/AST/AvailabilitySpec.cpp
@@ -24,45 +24,34 @@ using namespace swift;
 AvailabilitySpec *AvailabilitySpec::createWildcard(ASTContext &ctx,
                                                    SourceLoc starLoc) {
   return new (ctx)
-      AvailabilitySpec(AvailabilitySpecKind::Wildcard, std::nullopt, starLoc,
+      AvailabilitySpec({AvailabilityDomain::forUniversal(), true}, starLoc,
                        /*Version=*/{},
                        /*VersionStartLoc=*/{});
 }
 
-static AvailabilityDomain getDomainForSpecKind(AvailabilitySpecKind Kind) {
-  switch (Kind) {
-  case AvailabilitySpecKind::PlatformVersionConstraint:
-  case AvailabilitySpecKind::Wildcard:
-    llvm_unreachable("unexpected spec kind");
-  case AvailabilitySpecKind::LanguageVersionConstraint:
-    return AvailabilityDomain::forSwiftLanguage();
-  case AvailabilitySpecKind::PackageDescriptionVersionConstraint:
-    return AvailabilityDomain::forPackageDescription();
-  }
+AvailabilitySpec *AvailabilitySpec::createForDomain(ASTContext &ctx,
+                                                    AvailabilityDomain domain,
+                                                    SourceLoc loc,
+                                                    llvm::VersionTuple version,
+                                                    SourceRange versionRange) {
+  DEBUG_ASSERT(!version.empty());
+  return new (ctx)
+      AvailabilitySpec({domain, true}, SourceRange(loc, versionRange.End),
+                       version, versionRange.Start);
 }
 
-AvailabilitySpec *AvailabilitySpec::createPlatformAgnostic(
-    ASTContext &ctx, AvailabilitySpecKind kind, SourceLoc nameLoc,
+AvailabilitySpec *AvailabilitySpec::createForUnknownDomain(
+    ASTContext &ctx, Identifier domainIdentifier, SourceLoc loc,
     llvm::VersionTuple version, SourceRange versionRange) {
-  return new (ctx) AvailabilitySpec(kind, getDomainForSpecKind(kind),
-                                    SourceRange(nameLoc, versionRange.End),
-                                    version, versionRange.Start);
-}
-
-static std::optional<AvailabilityDomain>
-getDomainForPlatform(PlatformKind Platform) {
-  if (Platform != PlatformKind::none)
-    return AvailabilityDomain::forPlatform(Platform);
-  return std::nullopt;
+  return new (ctx) AvailabilitySpec({domainIdentifier, true},
+                                    SourceRange(loc, versionRange.End), version,
+                                    versionRange.Start);
 }
 
-AvailabilitySpec *AvailabilitySpec::createPlatformVersioned(
-    ASTContext &ctx, PlatformKind platform, SourceLoc platformLoc,
-    llvm::VersionTuple version, SourceRange versionRange) {
-  return new (ctx) AvailabilitySpec(
-      AvailabilitySpecKind::PlatformVersionConstraint,
-      getDomainForPlatform(platform),
-      SourceRange(platformLoc, versionRange.End), version, versionRange.Start);
+AvailabilitySpec *AvailabilitySpec::clone(ASTContext &ctx) const {
+  return new (ctx)
+      AvailabilitySpec({getDomainOrIdentifier().copy(ctx), true},
+                       SrcRange, Version, VersionStartLoc);
 }
 
 llvm::VersionTuple SemanticAvailabilitySpec::getVersion() const {
diff --git a/lib/AST/Bridging/AvailabilityBridging.cpp b/lib/AST/Bridging/AvailabilityBridging.cpp
@@ -86,50 +86,31 @@ static BridgedPlatformKind bridge(PlatformKind platform) {
 // MARK: AvailabilitySpec
 //===----------------------------------------------------------------------===//
 
-static AvailabilitySpecKind unbridge(BridgedAvailabilitySpecKind kind) {
-  switch (kind) {
-  case BridgedAvailabilitySpecKindPlatformVersionConstraint:
-    return AvailabilitySpecKind::PlatformVersionConstraint;
-  case BridgedAvailabilitySpecKindWildcard:
-    return AvailabilitySpecKind::Wildcard;
-  case BridgedAvailabilitySpecKindLanguageVersionConstraint:
-    return AvailabilitySpecKind::LanguageVersionConstraint;
-  case BridgedAvailabilitySpecKindPackageDescriptionVersionConstraint:
-    return AvailabilitySpecKind::PackageDescriptionVersionConstraint;
-  }
-  llvm_unreachable("unhandled enum value");
-}
-
 BridgedAvailabilitySpec
 BridgedAvailabilitySpec_createWildcard(BridgedASTContext cContext,
                                        BridgedSourceLoc cLoc) {
   return AvailabilitySpec::createWildcard(cContext.unbridged(),
                                           cLoc.unbridged());
 }
 
-BridgedAvailabilitySpec BridgedAvailabilitySpec_createPlatformAgnostic(
-    BridgedASTContext cContext, BridgedAvailabilitySpecKind cKind,
+BridgedAvailabilitySpec BridgedAvailabilitySpec_createForDomain(
+    BridgedASTContext cContext, BridgedAvailabilityDomain cDomain,
     BridgedSourceLoc cLoc, BridgedVersionTuple cVersion,
     BridgedSourceRange cVersionRange) {
-  return AvailabilitySpec::createPlatformAgnostic(
-      cContext.unbridged(), unbridge(cKind), cLoc.unbridged(),
+  return AvailabilitySpec::createForDomain(
+      cContext.unbridged(), cDomain.unbridged(), cLoc.unbridged(),
       cVersion.unbridged(), cVersionRange.unbridged());
 }
 
-BridgedAvailabilitySpec BridgedAvailabilitySpec_createPlatformVersioned(
-    BridgedASTContext cContext, BridgedPlatformKind cPlatform,
-    BridgedSourceLoc cPlatformLoc, BridgedVersionTuple cVersion,
-    BridgedSourceRange cVersionSrcRange) {
-  return AvailabilitySpec::createPlatformVersioned(
-      cContext.unbridged(), unbridge(cPlatform), cPlatformLoc.unbridged(),
-      cVersion.unbridged(), cVersionSrcRange.unbridged());
-}
-
 BridgedSourceRange
 BridgedAvailabilitySpec_getSourceRange(BridgedAvailabilitySpec spec) {
   return spec.unbridged()->getSourceRange();
 }
 
+bool BridgedAvailabilitySpec_isWildcard(BridgedAvailabilitySpec spec) {
+  return spec.unbridged()->isWildcard();
+}
+
 BridgedAvailabilityDomain
 BridgedAvailabilitySpec_getDomain(BridgedAvailabilitySpec spec) {
   auto domain = spec.unbridged()->getDomain();
diff --git a/lib/ASTGen/Sources/ASTGen/Availability.swift b/lib/ASTGen/Sources/ASTGen/Availability.swift
@@ -72,6 +72,9 @@ extension ASTGenVisitor {
 
     var result: [BridgedAvailableAttr] = []
     for spec in specs {
+      guard !spec.isWildcard else {
+        continue
+      }
       let domain = spec.domain
       guard !domain.isNull() else {
         continue
@@ -287,13 +290,13 @@ extension ASTGenVisitor {
 
       switch domainNode.rawText {
       case "swift", "_PackageVersion":
-        let kind: BridgedAvailabilitySpecKind = domainNode.rawText == "swift"
-          ? .languageVersionConstraint
-          : .packageDescriptionVersionConstraint
+        let domain: BridgedAvailabilityDomain = domainNode.rawText == "swift"
+          ? .forSwiftLanguage()
+          : .forPackageDescription()
 
-        let spec = BridgedAvailabilitySpec.createPlatformAgnostic(
+        let spec = BridgedAvailabilitySpec.create(
           self.ctx,
-          kind: kind,
+          domain: domain,
           nameLoc: nameLoc,
           version: version?.bridged ?? BridgedVersionTuple(),
           versionRange: versionRange
@@ -329,10 +332,10 @@ extension ASTGenVisitor {
             // TODO: Diagnostics.
             fatalError("expected version")
           }
-          let spec = BridgedAvailabilitySpec.createPlatformVersioned(
+          let spec = BridgedAvailabilitySpec.create(
             self.ctx,
-            platform: platform,
-            platformLoc: nameLoc,
+            domain: BridgedAvailabilityDomain.forPlatform(platform),
+            nameLoc: nameLoc,
             version: version.bridged,
             versionRange: versionRange
           )
diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
diff --git a/lib/Sema/DerivedConformanceRawRepresentable.cpp b/lib/Sema/DerivedConformanceRawRepresentable.cpp
diff --git a/lib/Sema/TypeCheckAvailability.cpp b/lib/Sema/TypeCheckAvailability.cpp
