Merge pull request #79628 from tshortli/parse-custom-availability-queries

AST/Parse: Parse custom availability domain specs in `if #available(...)`

Author: tshortli

include/swift/AST/AvailabilityDomain.h

@@ -208,6 +208,9 @@ class AvailabilityDomain final {
   /// version ranges.
   bool isVersioned() const;
 
+  /// Returns true if the domain supports `#available`/`#unavailable` queries.
+  bool supportsQueries() const;
+
   /// Returns true if this domain is considered active in the current
   /// compilation context.
   bool isActive(const ASTContext &ctx) const;

include/swift/AST/DiagnosticsSema.def

@@ -6754,8 +6754,10 @@ NOTE(type_eraser_init_spi,none,
 //------------------------------------------------------------------------------
 
 ERROR(availability_must_occur_alone, none,
-      "'%0' version-availability must be specified alone", (StringRef))
-
+      "%0 %select{|version }1availability must be specified alone",
+      (StringRef, bool))
+ERROR(availability_unexpected_version, none,
+      "unexpected version number for %0", (StringRef))
 WARNING(availability_unrecognized_platform_name,
         PointsToFirstBadToken, "unrecognized platform name %0", (Identifier))
 WARNING(availability_suggest_platform_name,
@@ -6773,11 +6775,8 @@ WARNING(attr_availability_expected_version_spec, none,
        "expected 'introduced', 'deprecated', or 'obsoleted' in '%0' attribute "
        "for platform '%1'", (StringRef, StringRef))
 ERROR(attr_availability_requires_custom_availability, none,
-      "%0 requires -enable-experimental-feature CustomAvailability",
-      (Identifier))
-WARNING(attr_availability_unexpected_version,none,
-       "unexpected version number in '%0' attribute for '%1'",
-       (const DeclAttribute, StringRef))
+      "%0 requires '-enable-experimental-feature CustomAvailability'",
+      (StringRef))
 
 ERROR(availability_decl_unavailable, none,
       "%0 is unavailable%select{ in %2|}1%select{|: %3}3",
@@ -7002,14 +7001,12 @@ ERROR(conformance_availability_only_version_newer, none,
 // MARK: if #available(...)
 //------------------------------------------------------------------------------
 
-ERROR(availability_query_swift_not_allowed, none,
-      "Swift language version checks not allowed in %0(...)", (StringRef))
-
-ERROR(availability_query_package_description_not_allowed, none,
-      "PackageDescription version checks not allowed in %0(...)", (StringRef))
+ERROR(availability_query_not_allowed, none,
+      "%0 %select{|version }1checks not allowed in %2(...)",
+      (StringRef, bool, StringRef))
 
-ERROR(availability_query_repeated_platform, none,
-      "version for '%0' already specified", (StringRef))
+ERROR(availability_query_already_specified, none,
+      "%select{|version for }0'%1' already specified", (bool, StringRef))
 
 ERROR(availability_query_wildcard_required, none,
       "must handle potential future platforms with '*'", ())

lib/AST/Availability.cpp

@@ -835,8 +835,9 @@ SemanticAvailableAttrRequest::evaluate(swift::Evaluator &evaluator,
       versionSourceRange = semanticAttr.getObsoletedSourceRange();
 
     diags
-        .diagnose(attrLoc, diag::attr_availability_unexpected_version, attr,
-                  domainName)
+        .diagnose(attrLoc, diag::availability_unexpected_version,
+                  domain->getNameForDiagnostics())
+        .limitBehaviorIf(domain->isUniversal(), DiagnosticBehavior::Warning)
         .highlight(versionSourceRange);
     return std::nullopt;
   }
@@ -862,11 +863,18 @@ SemanticAvailableAttrRequest::evaluate(swift::Evaluator &evaluator,
     case AvailableAttr::Kind::Default:
       break;
     }
+  }
 
-    if (!hasVersionSpec) {
-      diags.diagnose(attrLoc, diag::attr_availability_expected_version_spec,
+  if (!hasVersionSpec && domain->isVersioned()) {
+    switch (attr->getKind()) {
+    case AvailableAttr::Kind::Default:
+      diags.diagnose(domainLoc, diag::attr_availability_expected_version_spec,
                      attrName, domainName);
       return std::nullopt;
+    case AvailableAttr::Kind::Deprecated:
+    case AvailableAttr::Kind::Unavailable:
+    case AvailableAttr::Kind::NoAsync:
+      break;
     }
   }
 

lib/AST/AvailabilityDomain.cpp

@@ -75,6 +75,19 @@ bool AvailabilityDomain::isVersioned() const {
   }
 }
 
+bool AvailabilityDomain::supportsQueries() const {
+  switch (getKind()) {
+  case Kind::Universal:
+  case Kind::Embedded:
+  case Kind::SwiftLanguage:
+  case Kind::PackageDescription:
+    return false;
+  case Kind::Platform:
+  case Kind::Custom:
+    return true;
+  }
+}
+
 bool AvailabilityDomain::isActive(const ASTContext &ctx) const {
   switch (getKind()) {
   case Kind::Universal:
@@ -94,7 +107,7 @@ bool AvailabilityDomain::isActive(const ASTContext &ctx) const {
 llvm::StringRef AvailabilityDomain::getNameForDiagnostics() const {
   switch (getKind()) {
   case Kind::Universal:
-    return "";
+    return "*";
   case Kind::SwiftLanguage:
     return "Swift";
   case Kind::PackageDescription:
@@ -247,7 +260,7 @@ AvailabilityDomainOrIdentifier::lookUpInDeclContext(
       !ctx.LangOpts.hasFeature(Feature::CustomAvailability) &&
       !declContext->isInSwiftinterface()) {
     diags.diagnose(loc, diag::attr_availability_requires_custom_availability,
-                   identifier);
+                   domain->getNameForDiagnostics());
     return std::nullopt;
   }
 

lib/AST/AvailabilitySpec.cpp

@@ -29,22 +29,32 @@ AvailabilitySpec *AvailabilitySpec::createWildcard(ASTContext &ctx,
                                     /*VersionStartLoc=*/{});
 }
 
+static SourceRange getSpecSourceRange(SourceLoc domainLoc,
+                                      SourceRange versionRange) {
+  if (domainLoc.isInvalid())
+    return SourceRange();
+
+  if (versionRange.isValid())
+    return SourceRange(domainLoc, versionRange.End);
+
+  return SourceRange(domainLoc);
+}
+
 AvailabilitySpec *AvailabilitySpec::createForDomain(ASTContext &ctx,
                                                     AvailabilityDomain domain,
                                                     SourceLoc loc,
                                                     llvm::VersionTuple version,
                                                     SourceRange versionRange) {
-  DEBUG_ASSERT(!version.empty());
-  return new (ctx) AvailabilitySpec(domain, SourceRange(loc, versionRange.End),
-                                    version, versionRange.Start);
+  return new (ctx)
+      AvailabilitySpec(domain, getSpecSourceRange(loc, versionRange), version,
+                       versionRange.Start);
 }
 
 AvailabilitySpec *AvailabilitySpec::createForDomainIdentifier(
     ASTContext &ctx, Identifier domainIdentifier, SourceLoc loc,
     llvm::VersionTuple version, SourceRange versionRange) {
-  DEBUG_ASSERT(!version.empty());
   return new (ctx)
-      AvailabilitySpec(domainIdentifier, SourceRange(loc, versionRange.End),
+      AvailabilitySpec(domainIdentifier, getSpecSourceRange(loc, versionRange),
                        version, versionRange.Start);
 }
 

lib/ASTGen/Sources/ASTGen/Availability.swift

@@ -284,6 +284,7 @@ extension ASTGenVisitor {
     var result: [BridgedAvailabilitySpec] = []
 
     func handle(domainNode: TokenSyntax, versionNode: VersionTupleSyntax?) {
+      // FIXME: [availability] Add support for custom domains
       let nameLoc = self.generateSourceLoc(domainNode)
       let version = self.generate(versionTuple: versionNode)
       let versionRange = self.generateSourceRange(versionNode)

lib/Parse/ParseExpr.cpp

@@ -3715,9 +3715,11 @@ ParserResult<AvailabilitySpec> Parser::parseAvailabilitySpec() {
   llvm::VersionTuple Version;
   SourceRange VersionRange;
 
-  if (parseVersionTuple(Version, VersionRange,
-                        diag::avail_query_expected_version_number)) {
-    return nullptr;
+  if (Tok.isAny(tok::integer_literal, tok::floating_literal)) {
+    if (parseVersionTuple(Version, VersionRange,
+                          diag::avail_query_expected_version_number)) {
+      return nullptr;
+    }
   }
 
   return makeParserResult(AvailabilitySpec::createForDomainIdentifier(

lib/Parse/ParseStmt.cpp

@@ -1481,7 +1481,7 @@ Parser::parseAvailabilitySpecList(SmallVectorImpl<AvailabilitySpec *> &Specs,
                      diag::avail_query_meant_introduced)
                 .fixItInsert(PlatformNameEndLoc, ", introduced:");
           }
-
+          consumeToken();
           Status.setIsParseError();
           break;
         }

lib/Sema/MiscDiagnostics.cpp

@@ -23,6 +23,7 @@
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/AvailabilitySpec.h"
 #include "swift/AST/ConformanceLookup.h"
+#include "swift/AST/DiagnosticsParse.h"
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Expr.h"
@@ -5130,6 +5131,8 @@ static bool diagnoseAvailabilityCondition(PoundAvailableInfo *info,
   StringRef queryName =
       info->isUnavailability() ? "#unavailable" : "#available";
 
+  bool hasValidSpecs = false;
+  bool allValidSpecsArePlatform = true;
   std::optional<SourceLoc> wildcardLoc;
   llvm::SmallSet<AvailabilityDomain, 8> seenDomains;
   for (auto spec : info->getSemanticAvailabilitySpecs(DC)) {
@@ -5140,24 +5143,44 @@ static bool diagnoseAvailabilityCondition(PoundAvailableInfo *info,
     }
 
     auto domain = spec.getDomain();
+    auto loc = parsedSpec->getStartLoc();
+    bool hasVersion = !spec.getVersion().empty();
 
-    if (!domain.isPlatform()) {
-      diags.diagnose(
-          parsedSpec->getStartLoc(),
-          domain.isSwiftLanguage()
-              ? diag::availability_query_swift_not_allowed
-              : diag::availability_query_package_description_not_allowed,
-          queryName);
+    if (!domain.supportsQueries()) {
+      diags.diagnose(loc, diag::availability_query_not_allowed,
+                     domain.getNameForDiagnostics(), hasVersion, queryName);
       return true;
     }
 
-    // Diagnose duplicate platforms.
+    if (!domain.isPlatform() && info->getQueries().size() > 1) {
+      diags.diagnose(loc, diag::availability_must_occur_alone,
+                     domain.getNameForDiagnostics(), hasVersion);
+      return true;
+    }
+
+    if (domain.isVersioned()) {
+      if (!hasVersion) {
+        diags.diagnose(loc, diag::avail_query_expected_version_number);
+        return true;
+      }
+    } else if (hasVersion) {
+      diags
+          .diagnose(loc, diag::availability_unexpected_version,
+                    domain.getNameForDiagnostics())
+          .highlight(parsedSpec->getVersionSrcRange());
+      return true;
+    }
+
+    // Diagnose duplicate domains.
     if (!seenDomains.insert(domain).second) {
-      diags.diagnose(parsedSpec->getStartLoc(),
-                     diag::availability_query_repeated_platform,
-                     domain.getNameForAttributePrinting());
+      diags.diagnose(loc, diag::availability_query_already_specified,
+                     domain.isVersioned(), domain.getNameForDiagnostics());
       return true;
     }
+
+    hasValidSpecs = true;
+    if (!domain.isPlatform())
+      allValidSpecsArePlatform = false;
   }
 
   if (info->isUnavailability()) {
@@ -5167,7 +5190,7 @@ static bool diagnoseAvailabilityCondition(PoundAvailableInfo *info,
                     diag::unavailability_query_wildcard_not_required)
           .fixItRemove(*wildcardLoc);
     }
-  } else if (!wildcardLoc) {
+  } else if (!wildcardLoc && hasValidSpecs && allValidSpecsArePlatform) {
     if (info->getQueries().size() > 0) {
       auto insertLoc = info->getQueries().back()->getSourceRange().End;
       diags.diagnose(insertLoc, diag::availability_query_wildcard_required)

lib/Sema/TypeCheckAttr.cpp

@@ -4979,8 +4979,9 @@ void AttributeChecker::checkAvailableAttrs(ArrayRef<AvailableAttr *> attrs) {
     llvm::SmallSet<AvailabilityDomain, 8> seenDomains;
 
     SourceLoc groupEndLoc;
-    bool requiresWildcard = false;
     bool foundWildcard = false;
+    bool hasValidSpecs = false;
+    bool allValidSpecsArePlatform = true;
     int groupAttrCount = 0;
     for (auto *groupedAttr = groupHead; groupedAttr != nullptr;
          groupedAttr = groupedAttr->getNextGroupedAvailableAttr()) {
@@ -4999,28 +5000,31 @@ void AttributeChecker::checkAvailableAttrs(ArrayRef<AvailableAttr *> attrs) {
         continue;
 
       auto domain = attr->getDomain();
-      if (domain.isPlatform())
-        requiresWildcard = true;
 
       if (groupAttrCount > 1 || !groupedAttr->isGroupTerminator() ||
           foundWildcard) {
         // Only platform availability is allowed to be written groups with more
         // than one member.
         if (!domain.isPlatform()) {
           diagnose(loc, diag::availability_must_occur_alone,
-                   domain.getNameForAttributePrinting());
+                   domain.getNameForDiagnostics(), domain.isVersioned());
           continue;
         }
       }
 
       // Diagnose duplicate platforms.
       if (!seenDomains.insert(domain).second) {
-        diagnose(loc, diag::availability_query_repeated_platform,
-                 domain.getNameForAttributePrinting());
+        diagnose(loc, diag::availability_query_already_specified,
+                 domain.isVersioned(), domain.getNameForAttributePrinting());
+        continue;
       }
+
+      hasValidSpecs = true;
+      if (!domain.isPlatform())
+        allValidSpecsArePlatform = false;
     }
 
-    if (requiresWildcard && !foundWildcard) {
+    if (!foundWildcard && hasValidSpecs && allValidSpecsArePlatform) {
       diagnose(groupEndLoc, diag::availability_query_wildcard_required)
           .fixItInsert(groupEndLoc, ", *");
     }