Sema: Move domain-specific @available attr diagnostics to type checking.

Since the domain is now resolved by SemanticAvailableAttrRequest, diagnosing
attributes with invalid combinations of fields for a specific domains needs to
be delayed.

Author: tshortli

include/swift/AST/DiagnosticsParse.def

@@ -1579,16 +1579,6 @@ ERROR(attr_availability_expected_equal,none,
 ERROR(attr_availability_expected_version,none,
       "expected version number in '%0' attribute", (StringRef))
 
-WARNING(attr_availability_platform_agnostic_expected_option,none,
-      "expected 'introduced', 'deprecated', or 'obsoleted' in '%0' attribute "
-      "for platform '%1'", (StringRef, StringRef))
-WARNING(attr_availability_platform_agnostic_expected_deprecated_version,none,
-      "expected version number with 'deprecated' in '%0' attribute for "
-      "platform '%1'", (StringRef, StringRef))
-WARNING(attr_availability_platform_agnostic_infeasible_option,none,
-      "'%0' cannot be used in '%1' attribute for platform '%2'",
-      (StringRef, StringRef, StringRef))
-
 WARNING(attr_availability_nonspecific_platform_unexpected_version,none,
       "unexpected version number in '%0' attribute for non-specific platform "
       "'*'", (StringRef))

include/swift/AST/DiagnosticsSema.def

@@ -6715,6 +6715,16 @@ NOTE(type_eraser_init_spi,none,
 // MARK: @available
 //------------------------------------------------------------------------------
 
+WARNING(attr_availability_expected_deprecated_version, none,
+       "expected version number with 'deprecated' in '%0' attribute for "
+       "platform '%1'", (StringRef, StringRef))
+WARNING(attr_availability_cannot_be_used_for_domain, none,
+       "'%0' cannot be used in '%1' attribute for platform '%2'",
+       (StringRef, StringRef, StringRef))
+WARNING(attr_availability_expected_version_spec, none,
+       "expected 'introduced', 'deprecated', or 'obsoleted' in '%0' attribute "
+       "for platform '%1'", (StringRef, StringRef))
+
 ERROR(availability_decl_unavailable, none,
       "%0 is unavailable%select{ in %2|}1%select{|: %3}3",
       (const ValueDecl *, bool, StringRef, StringRef))

lib/Parse/ParseDecl.cpp

@@ -542,62 +542,14 @@ ParserResult<AvailableAttr> Parser::parseExtendedAvailabilitySpecList(
              /*isDeclModifier*/ false);
   }
 
-  auto PlatformKind = platformFromString(Platform);
-  auto Domain = (PlatformKind && *PlatformKind != PlatformKind::none)
-                    ? AvailabilityDomain::forPlatform(*PlatformKind)
-                    : AvailabilityDomain::forUniversal();
-
-  // Treat 'swift' as a valid version-qualifying token, when
-  // at least some versions were mentioned and no other
-  // platform-agnostic availability spec has been provided.
-  bool SomeVersion = (!Introduced.empty() ||
-                      !Deprecated.empty() ||
-                      !Obsoleted.empty());
-  if (!PlatformKind.has_value() &&
-      (Platform == "swift" || Platform == "_PackageDescription")) {
-
-    if (AttrKind == AvailableAttr::Kind::Deprecated) {
-      diagnose(AttrLoc,
-               diag::attr_availability_platform_agnostic_expected_deprecated_version,
-               AttrName, Platform);
-      return nullptr;
-    }
-    if (AttrKind == AvailableAttr::Kind::Unavailable) {
-      diagnose(AttrLoc, diag::attr_availability_platform_agnostic_infeasible_option,
-               "unavailable", AttrName, Platform);
-      return nullptr;
-    }
-    assert(AttrKind == AvailableAttr::Kind::Default);
-
-    if (!SomeVersion) {
-      diagnose(AttrLoc, diag::attr_availability_platform_agnostic_expected_option,
-               AttrName, Platform);
-      return nullptr;
-    }
-
-    PlatformKind = PlatformKind::none;
-    Domain = (Platform == "swift")
-                 ? AvailabilityDomain::forSwiftLanguage()
-                 : AvailabilityDomain::forPackageDescription();
-  }
-
-
   if (AnyArgumentInvalid)
     return nullptr;
-  if (!PlatformKind.has_value()) {
-    if (auto CorrectedPlatform = closestCorrectedPlatformString(Platform)) {
-      diagnose(PlatformLoc, diag::attr_availability_suggest_platform, Platform,
-               AttrName, *CorrectedPlatform)
-          .fixItReplace(SourceRange(PlatformLoc), *CorrectedPlatform);
-    } else {
-      diagnose(AttrLoc, diag::attr_availability_unknown_platform, Platform,
-               AttrName);
-    }
-    return nullptr;
-  }
 
-  // Warn if any version is specified for non-specific platform '*'.
-  if (Domain.isUniversal() && SomeVersion) {
+  // Warn if any version is specified with the universal domain ('*').
+  bool SomeVersion = (!Introduced.empty() ||
+                      !Deprecated.empty() ||
+                      !Obsoleted.empty());
+  if (Platform == "*" && SomeVersion) {
     auto diag = diagnose(AttrLoc,
         diag::attr_availability_nonspecific_platform_unexpected_version,
         AttrName);
@@ -613,7 +565,7 @@ ParserResult<AvailableAttr> Parser::parseExtendedAvailabilitySpecList(
     return nullptr;
   }
 
-  if (PlatformKind) {
+  if (auto PlatformKind = platformFromString(Platform)) {
       if (!Introduced.empty())
         Introduced.Version =
             canonicalizePlatformVersion(*PlatformKind, Introduced.Version);

lib/Sema/TypeCheckAttr.cpp

@@ -8273,12 +8273,52 @@ SemanticAvailableAttrRequest::evaluate(swift::Evaluator &evaluator,
   if (attr->hasCachedDomain())
     return SemanticAvailableAttr(attr);
 
+  auto &diags = decl->getASTContext().Diags;
+  auto attrLoc = attr->getLocation();
+  auto attrName = attr->getAttrName();
+  auto attrKind = attr->getKind();
+  auto domainLoc = attr->getDomainLoc();
   auto string = attr->getDomainString();
   ASSERT(string);
 
+  // Attempt to resolve the domain specified for the attribute and diagnose
+  // if no domain is found.
   auto domain = AvailabilityDomain::builtinDomainForString(*string);
-  if (!domain)
+  if (!domain) {
+    if (auto suggestion = closestCorrectedPlatformString(*string)) {
+      diags
+          .diagnose(domainLoc, diag::attr_availability_suggest_platform,
+                    *string, attrName, *suggestion)
+          .fixItReplace(SourceRange(domainLoc), *suggestion);
+    } else {
+      diags.diagnose(attrLoc, diag::attr_availability_unknown_platform, *string,
+                     attrName);
+    }
     return std::nullopt;
+  }
+
+  if (domain->isSwiftLanguage() || domain->isPackageDescription()) {
+    if (attrKind == AvailableAttr::Kind::Deprecated) {
+      diags.diagnose(attrLoc,
+                     diag::attr_availability_expected_deprecated_version,
+                     attrName, *string);
+      return std::nullopt;
+    }
+    if (attrKind == AvailableAttr::Kind::Unavailable) {
+      diags.diagnose(attrLoc, diag::attr_availability_cannot_be_used_for_domain,
+                     "unavailable", attrName, *string);
+      return std::nullopt;
+    }
+    assert(attrKind == AvailableAttr::Kind::Default);
+
+    bool hasVersionSpec = (attr->getRawIntroduced() ||
+                           attr->getRawDeprecated() || attr->getRawObsoleted());
+    if (!hasVersionSpec) {
+      diags.diagnose(attrLoc, diag::attr_availability_expected_version_spec,
+                     attrName, *string);
+      return std::nullopt;
+    }
+  }
 
   const_cast<AvailableAttr *>(attr)->setCachedDomain(*domain);
   return SemanticAvailableAttr(attr);