AST: Retire OtherPlatformAvailabilitySpec.

Author: tshortli

include/swift/AST/ASTBridging.h

@@ -626,13 +626,18 @@ struct BridgedAvailabilityMacroDefinition {
 
 enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedAvailabilitySpecKind {
   BridgedAvailabilitySpecKindPlatformVersionConstraint,
-  BridgedAvailabilitySpecKindOtherPlatform,
+  BridgedAvailabilitySpecKindWildcard,
   BridgedAvailabilitySpecKindLanguageVersionConstraint,
   BridgedAvailabilitySpecKindPackageDescriptionVersionConstraint,
 };
 
 struct BridgedAvailabilityDomain;
 
+SWIFT_NAME("BridgedAvailabilitySpec.createWildcard(_:loc:)")
+BridgedAvailabilitySpec
+BridgedAvailabilitySpec_createWildcard(BridgedASTContext cContext,
+                                       BridgedSourceLoc cLoc);
+
 SWIFT_NAME("getter:BridgedAvailabilitySpec.sourceRange(self:)")
 BridgedSourceRange
 BridgedAvailabilitySpec_getSourceRange(BridgedAvailabilitySpec spec);
@@ -669,11 +674,6 @@ BridgedPlatformAgnosticVersionConstraintAvailabilitySpec_createParsed(
     BridgedSourceLoc cNameLoc, BridgedVersionTuple cVersion,
     BridgedSourceRange cVersionSrcRange);
 
-SWIFT_NAME("BridgedOtherPlatformAvailabilitySpec.createParsed(_:loc:)")
-BridgedOtherPlatformAvailabilitySpec
-BridgedOtherPlatformAvailabilitySpec_createParsed(BridgedASTContext cContext,
-                                                  BridgedSourceLoc cLoc);
-
 SWIFT_NAME("getter:BridgedPlatformVersionConstraintAvailabilitySpec."
            "asAvailabilitySpec(self:)")
 BridgedAvailabilitySpec
@@ -686,11 +686,6 @@ BridgedAvailabilitySpec
 BridgedPlatformAgnosticVersionConstraintAvailabilitySpec_asAvailabilitySpec(
     BridgedPlatformAgnosticVersionConstraintAvailabilitySpec spec);
 
-SWIFT_NAME(
-    "getter:BridgedOtherPlatformAvailabilitySpec.asAvailabilitySpec(self:)")
-BridgedAvailabilitySpec BridgedOtherPlatformAvailabilitySpec_asAvailabilitySpec(
-    BridgedOtherPlatformAvailabilitySpec spec);
-
 struct BridgedAvailabilityDomain {
   void *_Nullable opaque;
 

include/swift/AST/ASTBridgingWrappers.def

@@ -109,7 +109,6 @@ AST_BRIDGING_WRAPPER_NULLABLE(ArgumentList)
 AST_BRIDGING_WRAPPER_NULLABLE(AvailabilitySpec)
 AST_BRIDGING_WRAPPER_NULLABLE(PlatformVersionConstraintAvailabilitySpec)
 AST_BRIDGING_WRAPPER_NULLABLE(PlatformAgnosticVersionConstraintAvailabilitySpec)
-AST_BRIDGING_WRAPPER_NULLABLE(OtherPlatformAvailabilitySpec)
 AST_BRIDGING_WRAPPER_CONST_NONNULL(AvailabilityMacroMap)
 AST_BRIDGING_WRAPPER_NONNULL(PoundAvailableInfo)
 

include/swift/AST/AvailabilitySpec.h

@@ -30,18 +30,19 @@ namespace swift {
 class ASTContext;
 
 enum class AvailabilitySpecKind {
-    /// A platform-version constraint of the form "PlatformName X.Y.Z"
-    PlatformVersionConstraint,
+  /// A platform-version constraint of the form "PlatformName X.Y.Z"
+  PlatformVersionConstraint,
 
-    /// A wildcard constraint, spelled '*', that is equivalent
-    /// to CurrentPlatformName >= MinimumDeploymentTargetVersion
-    OtherPlatform,
+  /// A wildcard constraint, spelled '*', that is equivalent
+  /// to CurrentPlatformName >= MinimumDeploymentTargetVersion
+  Wildcard,
 
-    /// A language-version constraint of the form "swift X.Y.Z"
-    LanguageVersionConstraint,
+  /// A language-version constraint of the form "swift X.Y.Z"
+  LanguageVersionConstraint,
 
-    /// A PackageDescription version constraint of the form "_PackageDescription X.Y.Z"
-    PackageDescriptionVersionConstraint,
+  /// A PackageDescription version constraint of the form "_PackageDescription
+  /// X.Y.Z"
+  PackageDescriptionVersionConstraint,
 };
 
 /// The root class for specifications of API availability in availability
@@ -65,16 +66,29 @@ class AvailabilitySpec : public ASTAllocated<AvailabilitySpec> {
   // Location of the availability macro expanded to create this spec.
   SourceLoc MacroLoc;
 
-public:
   AvailabilitySpec(AvailabilitySpecKind Kind,
                    std::optional<AvailabilityDomain> Domain,
                    SourceRange SrcRange, llvm::VersionTuple Version,
                    SourceLoc VersionStartLoc)
       : Kind(Kind), Domain(Domain), SrcRange(SrcRange), Version(Version),
         VersionStartLoc(VersionStartLoc) {}
 
+public:
+  /// Creates a wildcard availability specification that guards execution
+  /// by checking that the run-time version is greater than the minimum
+  /// deployment target. This specification is designed to ease porting
+  /// to new platforms. Because new platforms typically branch from
+  /// existing platforms, the wildcard allows an #available() check to do the
+  /// "right" thing (executing the guarded branch) on the new platform without
+  /// requiring a modification to every availability guard in the program. Note
+  /// that we still do compile-time availability checking with '*', so the
+  /// compiler will still catch references to potentially unavailable symbols.
+  static AvailabilitySpec *createWildcard(ASTContext &ctx, SourceLoc starLoc);
+
   AvailabilitySpecKind getKind() const { return Kind; }
 
+  bool isWildcard() { return getKind() == AvailabilitySpecKind::Wildcard; }
+
   SourceRange getSourceRange() const { return SrcRange; }
   SourceLoc getStartLoc() const { return SrcRange.Start; }
 
@@ -147,7 +161,7 @@ class PlatformAgnosticVersionConstraintAvailabilitySpec
   static AvailabilityDomain getDomainForSpecKind(AvailabilitySpecKind Kind) {
     switch (Kind) {
     case AvailabilitySpecKind::PlatformVersionConstraint:
-    case AvailabilitySpecKind::OtherPlatform:
+    case AvailabilitySpecKind::Wildcard:
       llvm_unreachable("unexpected spec kind");
     case AvailabilitySpecKind::LanguageVersionConstraint:
       return AvailabilityDomain::forSwiftLanguage();
@@ -184,37 +198,6 @@ class PlatformAgnosticVersionConstraintAvailabilitySpec
   }
 };
 
-/// A wildcard availability specification that guards execution
-/// by checking that the run-time version is greater than the minimum
-/// deployment target. This specification is designed to ease porting
-/// to new platforms. Because new platforms typically branch from
-/// existing platforms, the wildcard allows an #available() check to do the
-/// "right" thing (executing the guarded branch) on the new platform without
-/// requiring a modification to every availability guard in the program. Note
-/// that we still do compile-time availability checking with '*', so the
-/// compiler will still catch references to potentially unavailable symbols.
-class OtherPlatformAvailabilitySpec : public AvailabilitySpec {
-public:
-  OtherPlatformAvailabilitySpec(SourceLoc StarLoc)
-      : AvailabilitySpec(AvailabilitySpecKind::OtherPlatform, std::nullopt,
-                         StarLoc,
-                         /*Version=*/{},
-                         /*VersionStartLoc=*/{}) {}
-
-  void print(raw_ostream &OS, unsigned Indent) const;
-
-  static bool classof(const AvailabilitySpec *Spec) {
-    return Spec->getKind() == AvailabilitySpecKind::OtherPlatform;
-  }
-
-  void *
-  operator new(size_t Bytes, ASTContext &C,
-               unsigned Alignment = alignof(OtherPlatformAvailabilitySpec)) {
-    return AvailabilitySpec::operator new(Bytes, C, AllocationArena::Permanent,
-                                          Alignment);
-  }
-};
-
 /// Maps of macro name and version to availability specifications.
 /// Organized as two nested \c DenseMap keyed first on the macro name then
 /// the macro version. This structure allows to peek at macro names before

lib/AST/ASTDumper.cpp

@@ -1128,8 +1128,8 @@ namespace {
               printFoot();
               break;
             }
-            case AvailabilitySpecKind::OtherPlatform:
-              printHead("other_constraint_availability_spec", PatternColor,
+            case AvailabilitySpecKind::Wildcard:
+              printHead("wildcard_constraint_availability_spec", PatternColor,
                         label);
               printFoot();
               break;

lib/AST/AvailabilitySpec.cpp

@@ -21,6 +21,14 @@
 
 using namespace swift;
 
+AvailabilitySpec *AvailabilitySpec::createWildcard(ASTContext &ctx,
+                                                   SourceLoc starLoc) {
+  return new (ctx)
+      AvailabilitySpec(AvailabilitySpecKind::Wildcard, std::nullopt, starLoc,
+                       /*Version=*/{},
+                       /*VersionStartLoc=*/{});
+}
+
 llvm::VersionTuple AvailabilitySpec::getVersion() const {
   switch (getKind()) {
   case AvailabilitySpecKind::PlatformVersionConstraint: {
@@ -40,7 +48,7 @@ llvm::VersionTuple AvailabilitySpec::getVersion() const {
   }
   case AvailabilitySpecKind::LanguageVersionConstraint:
   case AvailabilitySpecKind::PackageDescriptionVersionConstraint:
-  case AvailabilitySpecKind::OtherPlatform:
+  case AvailabilitySpecKind::Wildcard:
     return Version;
   }
 }
@@ -69,9 +77,3 @@ void PlatformAgnosticVersionConstraintAvailabilitySpec::print(raw_ostream &OS,
                     << " version='" << getVersion() << "'"
                     << ')';
 }
-
-void OtherPlatformAvailabilitySpec::print(raw_ostream &OS, unsigned Indent) const {
-  OS.indent(Indent) << '(' << "other_constraint_availability_spec"
-                    << " "
-                    << ')';
-}

lib/AST/Bridging/AvailabilityBridging.cpp

@@ -86,6 +86,13 @@ static BridgedPlatformKind bridge(PlatformKind platform) {
 // MARK: AvailabilitySpec
 //===----------------------------------------------------------------------===//
 
+BridgedAvailabilitySpec
+BridgedAvailabilitySpec_createWildcard(BridgedASTContext cContext,
+                                       BridgedSourceLoc cLoc) {
+  return AvailabilitySpec::createWildcard(cContext.unbridged(),
+                                          cLoc.unbridged());
+}
+
 BridgedSourceRange
 BridgedAvailabilitySpec_getSourceRange(BridgedAvailabilitySpec spec) {
   return spec.unbridged()->getSourceRange();
@@ -118,8 +125,8 @@ static AvailabilitySpecKind unbridge(BridgedAvailabilitySpecKind kind) {
   switch (kind) {
   case BridgedAvailabilitySpecKindPlatformVersionConstraint:
     return AvailabilitySpecKind::PlatformVersionConstraint;
-  case BridgedAvailabilitySpecKindOtherPlatform:
-    return AvailabilitySpecKind::OtherPlatform;
+  case BridgedAvailabilitySpecKindWildcard:
+    return AvailabilitySpecKind::Wildcard;
   case BridgedAvailabilitySpecKindLanguageVersionConstraint:
     return AvailabilitySpecKind::LanguageVersionConstraint;
   case BridgedAvailabilitySpecKindPackageDescriptionVersionConstraint:
@@ -149,13 +156,6 @@ BridgedPlatformAgnosticVersionConstraintAvailabilitySpec_createParsed(
           cVersionSrcRange.unbridged());
 }
 
-BridgedOtherPlatformAvailabilitySpec
-BridgedOtherPlatformAvailabilitySpec_createParsed(BridgedASTContext cContext,
-                                                  BridgedSourceLoc cLoc) {
-  return new (cContext.unbridged())
-      OtherPlatformAvailabilitySpec(cLoc.unbridged());
-}
-
 BridgedAvailabilitySpec
 BridgedPlatformVersionConstraintAvailabilitySpec_asAvailabilitySpec(
     BridgedPlatformVersionConstraintAvailabilitySpec spec) {
@@ -168,11 +168,6 @@ BridgedPlatformAgnosticVersionConstraintAvailabilitySpec_asAvailabilitySpec(
   return static_cast<AvailabilitySpec *>(spec.unbridged());
 }
 
-BridgedAvailabilitySpec BridgedOtherPlatformAvailabilitySpec_asAvailabilitySpec(
-    BridgedOtherPlatformAvailabilitySpec spec) {
-  return static_cast<AvailabilitySpec *>(spec.unbridged());
-}
-
 //===----------------------------------------------------------------------===//
 // MARK: AvailabilityDomain
 //===----------------------------------------------------------------------===//

lib/ASTGen/Sources/ASTGen/Availability.swift

@@ -344,11 +344,11 @@ extension ASTGenVisitor {
     for parsed in node {
       switch parsed.argument {
       case .token(let tok) where tok.rawText == "*":
-        let spec = BridgedOtherPlatformAvailabilitySpec.createParsed(
+        let spec = BridgedAvailabilitySpec.createWildcard(
           self.ctx,
           loc: self.generateSourceLoc(tok)
         )
-        result.append(spec.asAvailabilitySpec)
+        result.append(spec)
       case .token(let tok):
         handle(domainNode: tok, versionNode: nil)
       case .availabilityVersionRestriction(let platformVersion):

lib/Parse/ParseExpr.cpp

@@ -3689,7 +3689,7 @@ ParserResult<AvailabilitySpec> Parser::parseAvailabilitySpec() {
     SourceLoc StarLoc = Tok.getLoc();
     consumeToken();
 
-    return makeParserResult(new (Context) OtherPlatformAvailabilitySpec(StarLoc));
+    return makeParserResult(AvailabilitySpec::createWildcard(Context, StarLoc));
   }
   if (Tok.isIdentifierOrUnderscore() &&
        (Tok.getText() == "swift" || Tok.getText() == "_PackageDescription"))

lib/Parse/ParseStmt.cpp

@@ -1292,7 +1292,7 @@ validateAvailabilitySpecList(Parser &P,
                              SmallVectorImpl<AvailabilitySpec *> &Specs,
                              Parser::AvailabilitySpecSource Source) {
   llvm::SmallSet<PlatformKind, 4> Platforms;
-  std::optional<SourceLoc> OtherPlatformSpecLoc = std::nullopt;
+  std::optional<SourceLoc> WildcardSpecLoc = std::nullopt;
 
   if (Specs.size() == 1 &&
       isa<PlatformAgnosticVersionConstraintAvailabilitySpec>(Specs[0])) {
@@ -1305,8 +1305,8 @@ validateAvailabilitySpecList(Parser &P,
   SmallVector<AvailabilitySpec *, 5> RecognizedSpecs;
   for (auto *Spec : Specs) {
     RecognizedSpecs.push_back(Spec);
-    if (auto *OtherPlatSpec = dyn_cast<OtherPlatformAvailabilitySpec>(Spec)) {
-      OtherPlatformSpecLoc = OtherPlatSpec->getStartLoc();
+    if (Spec->isWildcard()) {
+      WildcardSpecLoc = Spec->getStartLoc();
       continue;
     }
 
@@ -1343,24 +1343,24 @@ validateAvailabilitySpecList(Parser &P,
 
   switch (Source) {
   case Parser::AvailabilitySpecSource::Available: {
-    if (OtherPlatformSpecLoc == std::nullopt) {
+    if (WildcardSpecLoc == std::nullopt) {
       SourceLoc InsertWildcardLoc = P.PreviousLoc;
       P.diagnose(InsertWildcardLoc, diag::availability_query_wildcard_required)
         .fixItInsertAfter(InsertWildcardLoc, ", *");
     }
     break;
   }
   case Parser::AvailabilitySpecSource::Unavailable: {
-    if (OtherPlatformSpecLoc != std::nullopt) {
-      SourceLoc Loc = OtherPlatformSpecLoc.value();
+    if (WildcardSpecLoc != std::nullopt) {
+      SourceLoc Loc = WildcardSpecLoc.value();
       P.diagnose(Loc, diag::unavailability_query_wildcard_not_required)
         .fixItRemove(Loc);
     }
     break;
   }
   case Parser::AvailabilitySpecSource::Macro: {
-    if (OtherPlatformSpecLoc != std::nullopt) {
-      SourceLoc Loc = OtherPlatformSpecLoc.value();
+    if (WildcardSpecLoc != std::nullopt) {
+      SourceLoc Loc = WildcardSpecLoc.value();
       P.diagnose(Loc, diag::attr_availability_wildcard_in_macro);
     }
     break;

lib/Sema/DerivedConformanceRawRepresentable.cpp

@@ -203,12 +203,12 @@ struct RuntimeVersionCheck {
     auto platformSpec = new (C) PlatformVersionConstraintAvailabilitySpec(
         Platform, SourceLoc(), Version, SourceLoc());
 
-    // otherSpec = "*"
-    auto otherSpec = new (C) OtherPlatformAvailabilitySpec(SourceLoc());
+    // wildcardSpec = "*"
+    auto wildcardSpec = AvailabilitySpec::createWildcard(C, SourceLoc());
 
-    // availableInfo = "#available(\(platformSpec), \(otherSpec))"
+    // availableInfo = "#available(\(platformSpec), \(wildcardSpec))"
     auto availableInfo = PoundAvailableInfo::create(
-        C, SourceLoc(), SourceLoc(), { platformSpec, otherSpec }, SourceLoc(),
+        C, SourceLoc(), SourceLoc(), {platformSpec, wildcardSpec}, SourceLoc(),
         false);
 
     // This won't be filled in by TypeCheckAvailability because we have

lib/Sema/TypeCheckAvailability.cpp

@@ -1273,7 +1273,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
         Query->setVariantAvailableRange(VariantRange);
       }
 
-      if (Spec->getKind() == AvailabilitySpecKind::OtherPlatform) {
+      if (Spec->isWildcard()) {
         // The wildcard spec '*' represents the minimum deployment target, so
         // there is no need to create an availability scope for this query.
         // Further, we won't diagnose for useless #available() conditions
@@ -1379,12 +1379,12 @@ class AvailabilityScopeBuilder : private ASTWalker {
   /// such spec exists.
   AvailabilitySpec *bestActiveSpecForQuery(PoundAvailableInfo *available,
                                            bool forTargetVariant = false) {
-    OtherPlatformAvailabilitySpec *FoundOtherSpec = nullptr;
+    AvailabilitySpec *FoundWildcardSpec = nullptr;
     PlatformVersionConstraintAvailabilitySpec *BestSpec = nullptr;
 
     for (auto *Spec : available->getQueries()) {
-      if (auto *OtherSpec = dyn_cast<OtherPlatformAvailabilitySpec>(Spec)) {
-        FoundOtherSpec = OtherSpec;
+      if (Spec->isWildcard()) {
+        FoundWildcardSpec = Spec;
         continue;
       }
 
@@ -1412,12 +1412,12 @@ class AvailabilityScopeBuilder : private ASTWalker {
 
     // If we have reached this point, we found no spec for our target, so
     // we return the other spec ('*'), if we found it, or nullptr, if not.
-    if (FoundOtherSpec) {
-      return FoundOtherSpec;
+    if (FoundWildcardSpec) {
+      return FoundWildcardSpec;
     } else if (available->isUnavailability()) {
       // For #unavailable, imply the presence of a wildcard.
       SourceLoc Loc = available->getRParenLoc();
-      return new (Context) OtherPlatformAvailabilitySpec(Loc);
+      return AvailabilitySpec::createWildcard(Context, Loc);
     } else {
       return nullptr;
     }
@@ -1426,7 +1426,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
   /// Return the availability context for the given spec.
   AvailabilityRange contextForSpec(AvailabilitySpec *Spec,
                                    bool GetRuntimeContext) {
-    if (isa<OtherPlatformAvailabilitySpec>(Spec)) {
+    if (Spec->isWildcard()) {
       return AvailabilityRange::alwaysAvailable();
     }