AST: Introduce SemanticAvailabilitySpec.

It wraps an type-checked `AvailabilitySpec`, which guarantees that the spec has
a valid `AvailabilityDomain` associated with it. This will unblock moving
AvailabilitySpec domain resolution from parsing to sema.

Author: tshortli

include/swift/AST/ASTBridging.h

@@ -732,9 +732,9 @@ SWIFT_NAME("getter:BridgedAvailabilitySpec.platform(self:)")
 BridgedPlatformKind
 BridgedAvailabilitySpec_getPlatform(BridgedAvailabilitySpec spec);
 
-SWIFT_NAME("getter:BridgedAvailabilitySpec.version(self:)")
+SWIFT_NAME("getter:BridgedAvailabilitySpec.rawVersion(self:)")
 BridgedVersionTuple
-BridgedAvailabilitySpec_getVersion(BridgedAvailabilitySpec spec);
+BridgedAvailabilitySpec_getRawVersion(BridgedAvailabilitySpec spec);
 
 SWIFT_NAME("getter:BridgedAvailabilitySpec.versionRange(self:)")
 BridgedSourceRange

include/swift/AST/AvailabilitySpec.h

@@ -21,9 +21,11 @@
 #include "swift/AST/AvailabilityDomain.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/PlatformKind.h"
+#include "swift/Basic/STLExtras.h"
 #include "swift/Basic/SourceLoc.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace swift {
@@ -45,6 +47,8 @@ enum class AvailabilitySpecKind {
   PackageDescriptionVersionConstraint,
 };
 
+class SemanticAvailabilitySpec;
+
 /// The root class for specifications of API availability in availability
 /// queries.
 class AvailabilitySpec : public ASTAllocated<AvailabilitySpec> {
@@ -109,7 +113,14 @@ class AvailabilitySpec : public ASTAllocated<AvailabilitySpec> {
 
   AvailabilitySpecKind getKind() const { return Kind; }
 
-  bool isWildcard() { return getKind() == AvailabilitySpecKind::Wildcard; }
+  bool isWildcard() const {
+    return getKind() == AvailabilitySpecKind::Wildcard;
+  }
+
+  /// Returns a type-checked representation of the spec, or `std::nullopt` if
+  /// the spec is invalid.
+  std::optional<SemanticAvailabilitySpec>
+  getSemanticAvailabilitySpec(const DeclContext *declContext) const;
 
   SourceRange getSourceRange() const { return SrcRange; }
   SourceLoc getStartLoc() const { return SrcRange.Start; }
@@ -122,13 +133,8 @@ class AvailabilitySpec : public ASTAllocated<AvailabilitySpec> {
     return PlatformKind::none;
   }
 
-  // The platform version to compare against.
-  llvm::VersionTuple getVersion() const;
-
-  // The version to be used in codegen for version comparisons at run time.
-  // This is required to support beta versions of macOS Big Sur that
-  // report 10.16 at run time.
-  llvm::VersionTuple getRuntimeVersion() const { return Version; }
+  // The version tuple that was written in source.
+  llvm::VersionTuple getRawVersion() const { return Version; }
 
   SourceRange getVersionSrcRange() const {
     if (!VersionStartLoc)
@@ -141,6 +147,67 @@ class AvailabilitySpec : public ASTAllocated<AvailabilitySpec> {
   void setMacroLoc(SourceLoc loc) { MacroLoc = loc; }
 };
 
+/// The type-checked representation of `AvailabilitySpec` which guaranatees that
+/// the spec has a valid `AvailabilityDomain`.
+class SemanticAvailabilitySpec {
+  const AvailabilitySpec *spec;
+
+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());
+  }
+
+  const AvailabilitySpec *getParsedSpec() const { return spec; }
+
+  AvailabilityDomain getDomain() const {
+    if (isWildcard())
+      return AvailabilityDomain::forUniversal();
+    return spec->getDomain().value();
+  }
+
+  bool isWildcard() const { return spec->isWildcard(); }
+
+  // The platform version to compare against.
+  llvm::VersionTuple getVersion() const;
+
+  // The version to be used in codegen for version comparisons at run time.
+  // This is required to support beta versions of macOS Big Sur that
+  // report 10.16 at run time.
+  llvm::VersionTuple getRuntimeVersion() const { return spec->getRawVersion(); }
+};
+
+/// Wraps an array of availability specs and provides an iterator for their
+/// semantic representations.
+class SemanticAvailabilitySpecs {
+public:
+  class Filter final {
+    const DeclContext *declContext;
+
+  public:
+    Filter(const DeclContext *declContext) : declContext(declContext) {}
+
+    std::optional<SemanticAvailabilitySpec>
+    operator()(const AvailabilitySpec *spec) const;
+  };
+
+  using Range = OptionalTransformRange<
+      iterator_range<ArrayRef<AvailabilitySpec *>::const_iterator>, Filter>;
+
+private:
+  Range specRange;
+
+public:
+  SemanticAvailabilitySpecs(ArrayRef<AvailabilitySpec *> specs,
+                            const DeclContext *declContext)
+      : specRange(llvm::make_range(specs.begin(), specs.end()),
+                  Filter(declContext)) {}
+
+  Range::iterator begin() const { return specRange.begin(); }
+  Range::iterator end() const { return specRange.end(); }
+  bool empty() const { return specRange.empty(); }
+};
+
 /// 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

include/swift/AST/Stmt.h

@@ -44,6 +44,7 @@ class FuncDecl;
 class AbstractFunctionDecl;
 class Pattern;
 class PatternBindingDecl;
+class SemanticAvailabilitySpecs;
 class VarDecl;
 class CaseStmt;
 class DoCatchStmt;
@@ -516,7 +517,11 @@ class alignas(8) PoundAvailableInfo final :
   ArrayRef<AvailabilitySpec *> getQueries() const {
     return llvm::ArrayRef(getTrailingObjects<AvailabilitySpec *>(), NumQueries);
   }
-  
+
+  /// Returns an iterator for the statement's type-checked availability specs.
+  SemanticAvailabilitySpecs
+  getSemanticAvailabilitySpecs(const DeclContext *declContext) const;
+
   SourceLoc getLParenLoc() const { return LParenLoc; }
   SourceLoc getRParenLoc() const { return RParenLoc; }
 

lib/AST/ASTDumper.cpp

@@ -1108,9 +1108,9 @@ namespace {
                     ? "*"
                     : Spec->getDomain()->getNameForAttributePrinting();
             printField(domainName, Label::always("domain"));
-            if (!Spec->getVersion().empty())
+            if (!Spec->getRawVersion().empty())
               printFieldRaw(
-                  [&](llvm::raw_ostream &OS) { OS << Spec->getVersion(); },
+                  [&](llvm::raw_ostream &OS) { OS << Spec->getRawVersion(); },
                   Label::always("version"));
             printFoot();
           },

lib/AST/AvailabilityScope.cpp

@@ -269,13 +269,13 @@ static SourceRange getAvailabilityConditionVersionSourceRange(
     const PoundAvailableInfo *PAI, const DeclContext *ReferenceDC,
     AvailabilityDomain Domain, const llvm::VersionTuple &Version) {
   SourceRange Range;
-  for (auto *Spec : PAI->getQueries()) {
-    if (Spec->getDomain() == Domain && Spec->getVersion() == Version) {
+  for (auto Spec : PAI->getSemanticAvailabilitySpecs(ReferenceDC)) {
+    if (Spec.getDomain() == Domain && Spec.getVersion() == Version) {
       // More than one: return invalid range, no unique choice.
       if (Range.isValid())
         return SourceRange();
       else
-        Range = Spec->getVersionSrcRange();
+        Range = Spec.getParsedSpec()->getVersionSrcRange();
     }
   }
   return Range;

lib/AST/AvailabilitySpec.cpp

@@ -65,7 +65,7 @@ AvailabilitySpec *AvailabilitySpec::createPlatformVersioned(
       SourceRange(platformLoc, versionRange.End), version, versionRange.Start);
 }
 
-llvm::VersionTuple AvailabilitySpec::getVersion() const {
+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
   // support Beta versions of macOS Big Sur where the OS
@@ -77,5 +77,22 @@ llvm::VersionTuple AvailabilitySpec::getVersion() const {
   //
   // we need to store the uncanonicalized version for codegen and canonicalize
   // it as necessary for compile-time checks.
-  return canonicalizePlatformVersion(getPlatform(), Version);
+  return canonicalizePlatformVersion(getDomain().getPlatformKind(),
+                                     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 {
+  if (auto semanticSpec = spec->getSemanticAvailabilitySpec(declContext))
+    return semanticSpec;
+  return std::nullopt;
 }

lib/AST/Bridging/AvailabilityBridging.cpp

@@ -144,8 +144,8 @@ BridgedAvailabilitySpec_getPlatform(BridgedAvailabilitySpec spec) {
 }
 
 BridgedVersionTuple
-BridgedAvailabilitySpec_getVersion(BridgedAvailabilitySpec spec) {
-  return spec.unbridged()->getVersion();
+BridgedAvailabilitySpec_getRawVersion(BridgedAvailabilitySpec spec) {
+  return spec.unbridged()->getRawVersion();
 }
 
 BridgedSourceRange

lib/AST/Stmt.cpp

@@ -619,6 +619,11 @@ PoundAvailableInfo::create(ASTContext &ctx, SourceLoc PoundLoc,
                                            RParenLoc, isUnavailability);
 }
 
+SemanticAvailabilitySpecs PoundAvailableInfo::getSemanticAvailabilitySpecs(
+    const DeclContext *declContext) const {
+  return SemanticAvailabilitySpecs(getQueries(), declContext);
+}
+
 SourceLoc PoundAvailableInfo::getEndLoc() const {
   if (RParenLoc.isInvalid()) {
     if (NumQueries == 0) {

lib/ASTGen/Sources/ASTGen/Availability.swift

@@ -85,7 +85,7 @@ extension ASTGenVisitor {
         kind: .default,
         message: BridgedStringRef(),
         renamed: BridgedStringRef(),
-        introduced: spec.version,
+        introduced: spec.rawVersion,
         introducedRange: spec.versionRange,
         deprecated: BridgedVersionTuple(),
         deprecatedRange: BridgedSourceRange(),
@@ -392,7 +392,7 @@ extension ASTGenVisitor {
             guard platform != .none else {
               continue
             }
-            result.append((platform: platform, version: spec.version))
+            result.append((platform: platform, version: spec.rawVersion))
           }
         }
         continue

lib/ConstExtract/ConstExtract.cpp

@@ -1052,11 +1052,12 @@ getConditionalMemberFromIfStmt(const IfStmt *ifStmt,
   }
   for (auto elt : ifStmt->getCond()) {
     if (elt.getKind() == StmtConditionElement::CK_Availability) {
-      for (auto *Q : elt.getAvailability()->getQueries()) {
-        if (Q->getPlatform() != PlatformKind::none) {
-          auto spec = BuilderValue::ConditionalMember::AvailabilitySpec(
-              *Q->getDomain(), Q->getVersion());
-          AvailabilitySpecs.push_back(spec);
+      for (auto spec :
+           elt.getAvailability()->getSemanticAvailabilitySpecs(declContext)) {
+        if (spec.getDomain().isPlatform()) {
+          AvailabilitySpecs.push_back(
+              BuilderValue::ConditionalMember::AvailabilitySpec(
+                  spec.getDomain(), spec.getVersion()));
         }
       }
       memberKind = BuilderValue::LimitedAvailability;