AST/Sema: Resolve AvailabilityDomain in SemanticAvailableAttrRequest.

Look up the AvailabilityDomain given its name during type checking, instead of
parsing.

include/swift/AST/Attr.h

@@ -912,6 +912,12 @@ private:
 private:
   friend class SemanticAvailableAttrRequest;
 
+  void setCachedDomain(AvailabilityDomain domain) {
+    assert(!Bits.AvailableAttr.HasDomain);
+    Domain = domain;
+    Bits.AvailableAttr.HasDomain = true;
+  }
+
   bool hasComputedSemanticAttr() const {
     return Bits.AvailableAttr.HasComputedSemanticAttr;
   }

include/swift/AST/AvailabilityDomain.h

@@ -140,6 +140,10 @@ public:
     return AvailabilityDomain(Kind::Embedded);
   }
 
+  /// Returns the built-in availability domain identified by the given string.
+  static std::optional<AvailabilityDomain>
+  builtinDomainForString(StringRef string);
+
   Kind getKind() const {
     if (auto inlineDomain = getInlineDomain())
       return inlineDomain->getKind();

lib/AST/AvailabilityDomain.cpp

@@ -13,9 +13,28 @@
 #include "swift/AST/AvailabilityDomain.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
+#include "llvm/ADT/StringSwitch.h"
 
 using namespace swift;
 
+std::optional<AvailabilityDomain>
+AvailabilityDomain::builtinDomainForString(StringRef string) {
+  auto domain = llvm::StringSwitch<std::optional<AvailabilityDomain>>(string)
+                    .Case("*", AvailabilityDomain::forUniversal())
+                    .Case("swift", AvailabilityDomain::forSwiftLanguage())
+                    .Case("_PackageDescription",
+                          AvailabilityDomain::forPackageDescription())
+                    .Default(std::nullopt);
+
+  if (domain)
+    return domain;
+
+  if (auto platformKind = platformFromString(string))
+    return AvailabilityDomain::forPlatform(*platformKind);
+
+  return std::nullopt;
+}
+
 bool AvailabilityDomain::isActive(const ASTContext &ctx) const {
   switch (getKind()) {
   case Kind::Universal:

lib/Parse/ParseDecl.cpp

@@ -628,8 +628,8 @@ ParserResult<AvailableAttr> Parser::parseExtendedAvailabilitySpecList(
   }
 
   auto Attr = new (Context) AvailableAttr(
-      AtLoc, SourceRange(AttrLoc, Tok.getLoc()), Domain, PlatformLoc, AttrKind,
+      AtLoc, SourceRange(AttrLoc, Tok.getLoc()), Platform, PlatformLoc,
-      Message, Renamed, Introduced.Version, Introduced.Range,
+      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

@@ -8270,6 +8270,17 @@ std::optional<SemanticAvailableAttr>
 SemanticAvailableAttrRequest::evaluate(swift::Evaluator &evaluator,
                                        const AvailableAttr *attr,
                                        const Decl *decl) const {
+  if (attr->hasCachedDomain())
+    return SemanticAvailableAttr(attr);
+
+  auto string = attr->getDomainString();
+  ASSERT(string);
+
+  auto domain = AvailabilityDomain::builtinDomainForString(*string);
+  if (!domain)
+    return std::nullopt;
+
+  const_cast<AvailableAttr *>(attr)->setCachedDomain(*domain);
   return SemanticAvailableAttr(attr);
 }