AST/Parse: Always delay AvailabilityDomain lookup to type-checking.

This will unblock parsing and type-checking availability queries that specify
custom availability domains, e.g.:

```
if #available(CustomDomain) {
  // Use declarations protected by @available(CustomDomain)
}
```

Author: tshortli

include/swift/AST/ASTBridging.h

@@ -691,13 +691,6 @@ struct BridgedAvailabilityMacroDefinition {
   BridgedArrayRef specs;
 };
 
-enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedAvailabilitySpecKind {
-  BridgedAvailabilitySpecKindPlatformVersionConstraint,
-  BridgedAvailabilitySpecKindWildcard,
-  BridgedAvailabilitySpecKindLanguageVersionConstraint,
-  BridgedAvailabilitySpecKindPackageDescriptionVersionConstraint,
-};
-
 struct BridgedAvailabilityDomain;
 
 SWIFT_NAME("BridgedAvailabilitySpec.createWildcard(_:loc:)")

include/swift/AST/AvailabilitySpec.h

@@ -74,12 +74,12 @@ class AvailabilitySpec : public ASTAllocated<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 requires a minimum version of
+  /// some availability domain which has not yet been resolved.
+  static AvailabilitySpec *
+  createForDomainIdentifier(ASTContext &ctx, Identifier domainIdentifier,
+                            SourceLoc loc, llvm::VersionTuple version,
+                            SourceRange versionRange);
 
   AvailabilitySpec *clone(ASTContext &ctx) const;
 
@@ -91,24 +91,14 @@ class AvailabilitySpec : public ASTAllocated<AvailabilitySpec> {
   SourceRange getSourceRange() const { return SrcRange; }
   SourceLoc getStartLoc() const { return SrcRange.Start; }
 
-  bool isWildcard() const {
-    if (auto domain = getDomain())
-      return domain->isUniversal();
-    return false;
-  }
-
   AvailabilityDomainOrIdentifier getDomainOrIdentifier() const {
     return DomainOrIdentifier;
   }
 
-  std::optional<AvailabilityDomain> getDomain() const {
-    return getDomainOrIdentifier().getAsDomain();
-  }
-
-  PlatformKind getPlatform() const {
-    if (auto domain = getDomain())
-      return domain->getPlatformKind();
-    return PlatformKind::none;
+  bool isWildcard() const {
+    if (auto domain = getDomainOrIdentifier().getAsDomain())
+      return domain->isUniversal();
+    return false;
   }
 
   // The version tuple that was written in source.
@@ -140,15 +130,14 @@ class SemanticAvailabilitySpec {
 public:
   SemanticAvailabilitySpec(const AvailabilitySpec *spec) : spec(spec) {
     // The domain must be resolved in order to wrap it in a semantic spec.
-    ASSERT(spec->isWildcard() || spec->getDomain());
+    bool hasDomain = spec->getDomainOrIdentifier().isDomain();
+    ASSERT(hasDomain);
   }
 
   const AvailabilitySpec *getParsedSpec() const { return spec; }
 
   AvailabilityDomain getDomain() const {
-    if (isWildcard())
-      return AvailabilityDomain::forUniversal();
-    return spec->getDomain().value();
+    return spec->getDomainOrIdentifier().getAsDomain().value();
   }
 
   bool isWildcard() const { return spec->isWildcard(); }

include/swift/AST/DiagnosticsParse.def

@@ -1972,13 +1972,6 @@ ERROR(avail_query_expected_version_number,PointsToFirstBadToken,
 ERROR(avail_query_expected_rparen,PointsToFirstBadToken,
       "expected ')' in availability query", ())
 
-WARNING(avail_query_unrecognized_platform_name,
-        PointsToFirstBadToken, "unrecognized platform name %0", (Identifier))
-WARNING(avail_query_suggest_platform_name,
-        PointsToFirstBadToken, "unrecognized platform name %0;"
-        " did you mean '%1'?",
-        (Identifier, StringRef))
-
 ERROR(avail_query_disallowed_operator, PointsToFirstBadToken,
       "'%0' cannot be used in an availability condition", (StringRef))
 

include/swift/AST/DiagnosticsSema.def

@@ -6738,6 +6738,16 @@ NOTE(type_eraser_init_spi,none,
 // MARK: @available
 //------------------------------------------------------------------------------
 
+ERROR(availability_must_occur_alone, none,
+      "'%0' version-availability must be specified alone", (StringRef))
+
+WARNING(availability_unrecognized_platform_name,
+        PointsToFirstBadToken, "unrecognized platform name %0", (Identifier))
+WARNING(availability_suggest_platform_name,
+        PointsToFirstBadToken, "unrecognized platform name %0;"
+        " did you mean '%1'?",
+        (Identifier, StringRef))
+
 WARNING(attr_availability_expected_deprecated_version, none,
        "expected version number with 'deprecated' in '%0' attribute for "
        "platform '%1'", (StringRef, StringRef))
@@ -6973,9 +6983,6 @@ ERROR(conformance_availability_only_version_newer, none,
       "conformance of %0 to %1 is only available in %2 %3 or newer",
       (Type, Type, StringRef, llvm::VersionTuple))
 
-ERROR(availability_must_occur_alone, none,
-      "'%0' version-availability must be specified alone", (StringRef))
-
 //------------------------------------------------------------------------------
 // MARK: if #available(...)
 //------------------------------------------------------------------------------

include/swift/Parse/Parser.h

@@ -2035,8 +2035,6 @@ class Parser {
                                    SmallVectorImpl<AvailabilitySpec *> &Specs);
 
   ParserResult<AvailabilitySpec> parseAvailabilitySpec();
-  ParserResult<AvailabilitySpec> parsePlatformVersionConstraintSpec();
-  ParserResult<AvailabilitySpec> parsePlatformAgnosticVersionConstraintSpec();
   bool
   parseAvailability(bool parseAsPartOfSpecializeAttr, StringRef AttrName,
                     bool &DiscardAttribute, SourceRange &attrRange,

lib/AST/AvailabilityDomain.cpp

@@ -13,7 +13,6 @@
 #include "swift/AST/AvailabilityDomain.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
-#include "swift/AST/DiagnosticsParse.h"
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/Basic/Assertions.h"
@@ -234,11 +233,11 @@ AvailabilityDomainOrIdentifier::lookUpInDeclContext(
     auto domainString = identifier.str();
     if (auto suggestion = closestCorrectedPlatformString(domainString)) {
       diags
-          .diagnose(loc, diag::avail_query_suggest_platform_name, identifier,
+          .diagnose(loc, diag::availability_suggest_platform_name, identifier,
                     *suggestion)
           .fixItReplace(SourceRange(loc), *suggestion);
     } else {
-      diags.diagnose(loc, diag::avail_query_unrecognized_platform_name,
+      diags.diagnose(loc, diag::availability_unrecognized_platform_name,
                      identifier);
     }
     return std::nullopt;

lib/AST/AvailabilitySpec.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/AvailabilitySpec.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/AvailabilityDomain.h"
+#include "swift/AST/DiagnosticsParse.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace swift;
@@ -38,7 +39,7 @@ AvailabilitySpec *AvailabilitySpec::createForDomain(ASTContext &ctx,
                                     version, versionRange.Start);
 }
 
-AvailabilitySpec *AvailabilitySpec::createForUnknownDomain(
+AvailabilitySpec *AvailabilitySpec::createForDomainIdentifier(
     ASTContext &ctx, Identifier domainIdentifier, SourceLoc loc,
     llvm::VersionTuple version, SourceRange versionRange) {
   DEBUG_ASSERT(!version.empty());
@@ -59,6 +60,18 @@ void AvailabilitySpec::print(llvm::raw_ostream &os) const {
     os << " " << getRawVersion().getAsString();
 }
 
+std::optional<SemanticAvailabilitySpec>
+AvailabilitySpec::getSemanticAvailabilitySpec(
+    const DeclContext *declContext) const {
+  AvailabilitySpec *mutableThis = const_cast<AvailabilitySpec *>(this);
+  auto domain = mutableThis->DomainOrIdentifier.resolveInDeclContext(
+      getStartLoc(), declContext);
+
+  if (domain)
+    return SemanticAvailabilitySpec(this);
+  return std::nullopt;
+}
+
 llvm::VersionTuple SemanticAvailabilitySpec::getVersion() const {
   // For macOS Big Sur, we canonicalize 10.16 to 11.0 for compile-time
   // checking since clang canonicalizes availability markup. However, to
@@ -75,14 +88,6 @@ llvm::VersionTuple SemanticAvailabilitySpec::getVersion() const {
                                      spec->getRawVersion());
 }
 
-std::optional<SemanticAvailabilitySpec>
-AvailabilitySpec::getSemanticAvailabilitySpec(
-    const DeclContext *declContext) const {
-  if (isWildcard() || getDomain())
-    return SemanticAvailabilitySpec(this);
-  return std::nullopt;
-}
-
 std::optional<SemanticAvailabilitySpec>
 SemanticAvailabilitySpecs::Filter::operator()(
     const AvailabilitySpec *spec) const {

lib/AST/Bridging/AvailabilityBridging.cpp

@@ -111,17 +111,22 @@ bool BridgedAvailabilitySpec_isWildcard(BridgedAvailabilitySpec spec) {
   return spec.unbridged()->isWildcard();
 }
 
+// FIXME: [availability] Remove this (re-implement ASTGen to match ParseDecl)
 BridgedAvailabilityDomain
 BridgedAvailabilitySpec_getDomain(BridgedAvailabilitySpec spec) {
-  auto domain = spec.unbridged()->getDomain();
+  auto domain = spec.unbridged()->getDomainOrIdentifier().getAsDomain();
   if (domain)
     return *domain;
   return BridgedAvailabilityDomain();
 }
 
+// FIXME: [availability] Remove this (re-implement ASTGen to match ParseDecl)
 BridgedPlatformKind
 BridgedAvailabilitySpec_getPlatform(BridgedAvailabilitySpec spec) {
-  return bridge(spec.unbridged()->getPlatform());
+  auto domain = spec.unbridged()->getDomainOrIdentifier().getAsDomain();
+  if (domain)
+    return bridge(domain->getPlatformKind());
+  return bridge(PlatformKind::none);
 }
 
 BridgedVersionTuple

lib/Parse/ParseDecl.cpp

@@ -798,22 +798,27 @@ bool Parser::parseAvailability(
       if (Spec->isWildcard())
         continue;
 
-      std::optional<AvailabilityDomain> Domain = Spec->getDomain();
-      if (!Domain)
+      auto DomainOrIdentifier = Spec->getDomainOrIdentifier();
+
+      // The domain should not be resolved during parsing.
+      DEBUG_ASSERT(!DomainOrIdentifier.isDomain());
+
+      auto DomainIdentifier = DomainOrIdentifier.getAsIdentifier();
+      if (!DomainIdentifier)
         continue;
 
-      auto Attr = new (Context)
-          AvailableAttr(AtLoc, attrRange, *Domain, Spec->getSourceRange().Start,
-                        AvailableAttr::Kind::Default,
-                        /*Message=*/StringRef(),
-                        /*Rename=*/StringRef(),
-                        /*Introduced=*/Spec->getRawVersion(),
-                        /*IntroducedRange=*/Spec->getVersionSrcRange(),
-                        /*Deprecated=*/llvm::VersionTuple(),
-                        /*DeprecatedRange=*/SourceRange(),
-                        /*Obsoleted=*/llvm::VersionTuple(),
-                        /*ObsoletedRange=*/SourceRange(),
-                        /*Implicit=*/false, AttrName == SPI_AVAILABLE_ATTRNAME);
+      auto Attr = new (Context) AvailableAttr(
+          AtLoc, attrRange, *DomainIdentifier, Spec->getSourceRange().Start,
+          AvailableAttr::Kind::Default,
+          /*Message=*/StringRef(),
+          /*Rename=*/StringRef(),
+          /*Introduced=*/Spec->getRawVersion(),
+          /*IntroducedRange=*/Spec->getVersionSrcRange(),
+          /*Deprecated=*/llvm::VersionTuple(),
+          /*DeprecatedRange=*/SourceRange(),
+          /*Obsoleted=*/llvm::VersionTuple(),
+          /*ObsoletedRange=*/SourceRange(),
+          /*Implicit=*/false, AttrName == SPI_AVAILABLE_ATTRNAME);
       addAttribute(Attr);
 
       Attr->setIsGroupMember();
@@ -1875,6 +1880,18 @@ Parser::parseAvailabilityMacro(SmallVectorImpl<AvailabilitySpec *> &Specs) {
   return makeParserSuccess();
 }
 
+static PlatformKind getPlatformFromDomainOrIdentifier(
+    const AvailabilityDomainOrIdentifier &domainOrIdentifier) {
+  if (auto domain = domainOrIdentifier.getAsDomain())
+    return domain->getPlatformKind();
+
+  if (auto platform =
+          platformFromString(domainOrIdentifier.getAsIdentifier()->str()))
+    return *platform;
+
+  return PlatformKind::none;
+}
+
 ParserStatus Parser::parsePlatformVersionInList(StringRef AttrName,
     llvm::SmallVector<PlatformAndVersion, 4> &PlatformAndVersions,
     bool &ParsedUnrecognizedPlatformName) {
@@ -1886,10 +1903,10 @@ ParserStatus Parser::parsePlatformVersionInList(StringRef AttrName,
       return MacroStatus;
 
     for (auto *Spec : Specs) {
-      auto Platform = Spec->getPlatform();
-      // Since peekAvailabilityMacroName() only matches defined availability
-      // macros, we only expect platform specific constraints here.
-      DEBUG_ASSERT(Platform != PlatformKind::none);
+      auto Platform =
+          getPlatformFromDomainOrIdentifier(Spec->getDomainOrIdentifier());
+      if (Platform == PlatformKind::none)
+        continue;
 
       auto Version = Spec->getRawVersion();
       if (Version.getSubminor().has_value() || Version.getBuild().has_value()) {

lib/Parse/ParseExpr.cpp

@@ -3674,8 +3674,6 @@ void Parser::validateCollectionElement(ParserResult<Expr> element) {
   }
 }
 
-
-
 /// Parse availability query specification.
 ///
 ///  availability-spec:
@@ -3690,51 +3688,7 @@ ParserResult<AvailabilitySpec> Parser::parseAvailabilitySpec() {
 
     return makeParserResult(AvailabilitySpec::createWildcard(Context, StarLoc));
   }
-  if (Tok.isIdentifierOrUnderscore() &&
-       (Tok.getText() == "swift" || Tok.getText() == "_PackageDescription"))
-      return parsePlatformAgnosticVersionConstraintSpec();
-
-  return parsePlatformVersionConstraintSpec();
-}
 
-/// Parse platform-agnostic version constraint specification.
-///
-///  language-version-constraint-spec:
-///     "swift" version-tuple
-///  package-description-version-constraint-spec:
-///     "_PackageDescription" version-tuple
-ParserResult<AvailabilitySpec>
-Parser::parsePlatformAgnosticVersionConstraintSpec() {
-  SourceLoc PlatformAgnosticNameLoc;
-  llvm::VersionTuple Version;
-  std::optional<AvailabilityDomain> Domain;
-  SourceRange VersionRange;
-
-  if (Tok.isIdentifierOrUnderscore()) {
-    if (Tok.getText() == "swift")
-      Domain = AvailabilityDomain::forSwiftLanguage();
-    else if (Tok.getText() == "_PackageDescription")
-      Domain = AvailabilityDomain::forPackageDescription();
-  }
-
-  if (!Domain.has_value())
-    return nullptr;
-
-  PlatformAgnosticNameLoc = Tok.getLoc();
-  consumeToken();
-  if (parseVersionTuple(Version, VersionRange,
-                        diag::avail_query_expected_version_number)) {
-    return nullptr;
-  }
-  return makeParserResult(AvailabilitySpec::createForDomain(
-      Context, Domain.value(), PlatformAgnosticNameLoc, Version, VersionRange));
-}
-
-/// Parse platform-version constraint specification.
-///
-///  platform-version-constraint-spec:
-///     identifier version-comparison version-tuple
-ParserResult<AvailabilitySpec> Parser::parsePlatformVersionConstraintSpec() {
   Identifier PlatformIdentifier;
   SourceLoc PlatformLoc;
   if (Tok.is(tok::code_complete)) {
@@ -3765,24 +3719,6 @@ ParserResult<AvailabilitySpec> Parser::parsePlatformVersionConstraintSpec() {
     return nullptr;
   }
 
-  std::optional<PlatformKind> Platform =
-      platformFromString(PlatformIdentifier.str());
-
-  if (!Platform.has_value() || Platform.value() == PlatformKind::none) {
-    if (auto CorrectedPlatform =
-            closestCorrectedPlatformString(PlatformIdentifier.str())) {
-      diagnose(PlatformLoc, diag::avail_query_suggest_platform_name,
-               PlatformIdentifier, *CorrectedPlatform)
-          .fixItReplace(PlatformLoc, *CorrectedPlatform);
-    } else {
-      diagnose(PlatformLoc, diag::avail_query_unrecognized_platform_name,
-               PlatformIdentifier);
-    }
-    return makeParserResult(AvailabilitySpec::createForUnknownDomain(
-        Context, PlatformIdentifier, PlatformLoc, Version, VersionRange));
-  }
-
-  return makeParserResult(AvailabilitySpec::createForDomain(
-      Context, AvailabilityDomain::forPlatform(Platform.value()), PlatformLoc,
-      Version, VersionRange));
+  return makeParserResult(AvailabilitySpec::createForDomainIdentifier(
+      Context, PlatformIdentifier, PlatformLoc, Version, VersionRange));
 }