AST: Introduce a Swift runtime availability domain.

Add support for the `Swift` availability domain, which represents availability
with respect to the Swift runtime. Use of this domain is restricted by the
experimental feature `SwiftRuntimeAvailability`.

Author: tshortli

include/swift/AST/AvailabilityDomain.h

@@ -51,6 +51,9 @@ class AvailabilityDomain final {
     /// Represents availability with respect to Swift language mode.
     SwiftLanguageMode,
 
+    /// Represents availability with respect to the Swift runtime.
+    SwiftRuntime,
+
     /// Represents PackageDescription availability.
     PackageDescription,
 
@@ -144,6 +147,10 @@ class AvailabilityDomain final {
     return AvailabilityDomain(Kind::SwiftLanguageMode);
   }
 
+  static AvailabilityDomain forSwiftRuntime() {
+    return AvailabilityDomain(Kind::SwiftRuntime);
+  }
+
   static AvailabilityDomain forPackageDescription() {
     return AvailabilityDomain(Kind::PackageDescription);
   }
@@ -185,6 +192,8 @@ class AvailabilityDomain final {
     return getKind() == Kind::SwiftLanguageMode;
   }
 
+  bool isSwiftRuntime() const { return getKind() == Kind::SwiftRuntime; }
+
   bool isPackageDescription() const {
     return getKind() == Kind::PackageDescription;
   }
@@ -236,6 +245,10 @@ class AvailabilityDomain final {
   bool isActivePlatform(const ASTContext &ctx,
                         bool forTargetVariant = false) const;
 
+  /// Returns true if availability in this domain must be specified alone in
+  /// `@available` attributes and `if #available` queries.
+  bool mustBeSpecifiedAlone() const;
+
   /// Returns the domain's minimum available range for type checking. For
   /// example, for the domain of the platform that compilation is targeting,
   /// this version is specified with the `-target` option. For the Swift

include/swift/Basic/LangOptions.h

@@ -188,6 +188,9 @@ namespace swift {
     /// Swift runtime version to compile for.
     version::Version RuntimeVersion = version::Version::getCurrentLanguageVersion();
 
+    /// The minimum Swift runtime version that the progam can be deployed to.
+    version::Version MinSwiftRuntimeVersion;
+
     /// PackageDescription version to compile for.
     version::Version PackageDescriptionVersion;
 

include/swift/Option/Options.td

@@ -298,6 +298,13 @@ def language_mode : Separate<["-"], "language-mode">,
   MetaVarName<"<mode>">,
   Alias<swift_version>;
 
+def min_swift_runtime_version
+    : Separate<["-"], "min-swift-runtime-version">,
+      Flags<[FrontendOption, ModuleInterfaceOptionIgnorable]>,
+      HelpText<"The minimum Swift runtime version "
+               "that will be available at runtime">,
+      MetaVarName<"<vers>">;
+
 def package_description_version: Separate<["-"], "package-description-version">,
   Flags<[FrontendOption, HelpHidden, ModuleInterfaceOption]>,
   HelpText<"The version number to be applied on the input for the PackageDescription availability kind">,

lib/AST/Availability.cpp

@@ -640,6 +640,7 @@ computeDeclRuntimeAvailability(const Decl *decl) {
     if (!domain.isActive(ctx) && !isTargetDomain)
       continue;
 
+    // FIXME: [runtime availability] Update this?
     if (!domain.isRoot())
       continue;
 
@@ -855,7 +856,8 @@ SemanticAvailableAttrRequest::evaluate(swift::Evaluator &evaluator,
     return std::nullopt;
   }
 
-  if (domain->isSwiftLanguageMode() || domain->isPackageDescription()) {
+  if (domain->isSwiftLanguageMode() || domain->isPackageDescription() ||
+      domain->isSwiftRuntime()) {
     switch (attr->getKind()) {
     case AvailableAttr::Kind::Deprecated:
       diags.diagnose(attrLoc,

lib/AST/AvailabilityConstraint.cpp

@@ -343,6 +343,7 @@ domainCanBeUnconditionallyUnavailableAtRuntime(AvailabilityDomain domain,
     return domain.isActive(ctx);
 
   case AvailabilityDomain::Kind::SwiftLanguageMode:
+  case AvailabilityDomain::Kind::SwiftRuntime:
   case AvailabilityDomain::Kind::PackageDescription:
     return false;
 
@@ -370,6 +371,7 @@ domainIsUnavailableAtRuntimeIfUnintroduced(AvailabilityDomain domain,
   case AvailabilityDomain::Kind::Universal:
   case AvailabilityDomain::Kind::Platform:
   case AvailabilityDomain::Kind::SwiftLanguageMode:
+  case AvailabilityDomain::Kind::SwiftRuntime:
   case AvailabilityDomain::Kind::PackageDescription:
     return false;
 

lib/AST/AvailabilityDomain.cpp

@@ -112,6 +112,7 @@ AvailabilityDomain::builtinDomainForString(StringRef string,
           .Case("*", AvailabilityDomain::forUniversal())
           .Case("swift", AvailabilityDomain::forSwiftLanguageMode())
           .Case("SwiftLanguageMode", AvailabilityDomain::forSwiftLanguageMode())
+          .Case("Swift", AvailabilityDomain::forSwiftRuntime())
           .Case("_PackageDescription",
                 AvailabilityDomain::forPackageDescription())
           .Default(std::nullopt);
@@ -131,6 +132,7 @@ bool AvailabilityDomain::isVersioned() const {
   case Kind::Embedded:
     return false;
   case Kind::SwiftLanguageMode:
+  case Kind::SwiftRuntime:
   case Kind::PackageDescription:
   case Kind::Platform:
     return true;
@@ -151,6 +153,12 @@ bool AvailabilityDomain::isVersionValid(
   case Kind::SwiftLanguageMode:
   case Kind::PackageDescription:
     return true;
+  case Kind::SwiftRuntime:
+    // Swift 5.0 is the first ABI stable Swift runtime version.
+    if (version.getMajor() < 5)
+      return false;
+    return true;
+
   case Kind::Platform:
     if (auto osType = tripleOSTypeForPlatform(getPlatformKind()))
       return llvm::Triple::isValidVersionForOS(*osType, version);
@@ -167,6 +175,7 @@ bool AvailabilityDomain::supportsContextRefinement() const {
   case Kind::SwiftLanguageMode:
   case Kind::PackageDescription:
     return false;
+  case Kind::SwiftRuntime:
   case Kind::Platform:
   case Kind::Custom:
     return true;
@@ -180,6 +189,7 @@ bool AvailabilityDomain::supportsQueries() const {
   case Kind::SwiftLanguageMode:
   case Kind::PackageDescription:
     return false;
+  case Kind::SwiftRuntime:
   case Kind::Platform:
   case Kind::Custom:
     return true;
@@ -194,6 +204,8 @@ bool AvailabilityDomain::isActive(const ASTContext &ctx,
   case Kind::PackageDescription:
   case Kind::Embedded:
     return true;
+  case Kind::SwiftRuntime:
+    return ctx.LangOpts.hasFeature(Feature::SwiftRuntimeAvailability);
   case Kind::Platform:
     return isPlatformActive(getPlatformKind(), ctx.LangOpts, forTargetVariant);
   case Kind::Custom:
@@ -211,6 +223,24 @@ bool AvailabilityDomain::isActivePlatform(const ASTContext &ctx,
   return isActive(ctx, forTargetVariant);
 }
 
+bool AvailabilityDomain::mustBeSpecifiedAlone() const {
+  switch (getKind()) {
+  case Kind::Universal:
+  case Kind::SwiftLanguageMode:
+  case Kind::PackageDescription:
+  case Kind::Embedded:
+  case Kind::Custom:
+    return true;
+  case Kind::SwiftRuntime:
+  case Kind::Platform:
+    // Platform and Swift runtime availability specifications can appear
+    // together, e.g. `@available(Swift 6, macOS 15, iOS 18, *)`.
+    // If there are ever multiple disjoint groups of domains that may be
+    // specified together in the future, this will need to be re-designed.
+    return false;
+  }
+}
+
 static std::optional<llvm::VersionTuple>
 getDeploymentVersion(const AvailabilityDomain &domain, const ASTContext &ctx) {
   switch (domain.getKind()) {
@@ -222,6 +252,10 @@ getDeploymentVersion(const AvailabilityDomain &domain, const ASTContext &ctx) {
     return ctx.LangOpts.EffectiveLanguageVersion;
   case AvailabilityDomain::Kind::PackageDescription:
     return ctx.LangOpts.PackageDescriptionVersion;
+  case AvailabilityDomain::Kind::SwiftRuntime:
+    if (!ctx.LangOpts.hasFeature(Feature::SwiftRuntimeAvailability))
+      return std::nullopt;
+    return ctx.LangOpts.MinSwiftRuntimeVersion;
   case AvailabilityDomain::Kind::Platform:
     if (domain.isActive(ctx))
       return ctx.LangOpts.getMinPlatformVersion();
@@ -256,6 +290,9 @@ llvm::StringRef AvailabilityDomain::getNameForDiagnostics() const {
   case Kind::Universal:
     return "*";
   case Kind::SwiftLanguageMode:
+    // FIXME: [runtime availability] Render language mode diags differently.
+    return "Swift";
+  case Kind::SwiftRuntime:
     return "Swift";
   case Kind::PackageDescription:
     return "PackageDescription";
@@ -274,6 +311,8 @@ llvm::StringRef AvailabilityDomain::getNameForAttributePrinting() const {
     return "*";
   case Kind::SwiftLanguageMode:
     return "swift";
+  case Kind::SwiftRuntime:
+    return "Swift";
   case Kind::PackageDescription:
     return "_PackageDescription";
   case Kind::Embedded:
@@ -308,6 +347,8 @@ bool AvailabilityDomain::contains(const AvailabilityDomain &other) const {
   case Kind::Embedded:
   case Kind::Custom:
     return other == *this;
+  case Kind::SwiftRuntime:
+    return other.isPlatform() || other == *this;
   case Kind::Platform:
     if (getPlatformKind() == other.getPlatformKind())
       return true;
@@ -321,6 +362,7 @@ bool AvailabilityDomain::isRoot() const {
   case AvailabilityDomain::Kind::Universal:
   case AvailabilityDomain::Kind::Embedded:
   case AvailabilityDomain::Kind::SwiftLanguageMode:
+  case AvailabilityDomain::Kind::SwiftRuntime:
   case AvailabilityDomain::Kind::PackageDescription:
     return true;
   case AvailabilityDomain::Kind::Platform:
@@ -406,6 +448,7 @@ AvailabilityDomain AvailabilityDomain::copy(ASTContext &ctx) const {
   switch (getKind()) {
   case Kind::Universal:
   case Kind::SwiftLanguageMode:
+  case Kind::SwiftRuntime:
   case Kind::PackageDescription:
   case Kind::Embedded:
   case Kind::Platform:
@@ -428,6 +471,7 @@ bool StableAvailabilityDomainComparator::operator()(
   switch (lhsKind) {
   case AvailabilityDomain::Kind::Universal:
   case AvailabilityDomain::Kind::SwiftLanguageMode:
+  case AvailabilityDomain::Kind::SwiftRuntime:
   case AvailabilityDomain::Kind::PackageDescription:
   case AvailabilityDomain::Kind::Embedded:
     return false;
@@ -504,31 +548,41 @@ AvailabilityDomainOrIdentifier::lookUpInDeclContext(
     return std::nullopt;
   }
 
-  if (!declContext->isInSwiftinterface()) {
-    if (domain->isCustom() && !hasCustomAvailability) {
-      diags.diagnose(loc, diag::availability_domain_requires_feature, *domain,
-                     "CustomAvailability");
-      return std::nullopt;
+  // The remaining diagnostics are suppressed in .swiftinterfaces.
+  if (declContext->isInSwiftinterface())
+    return domain;
+
+  // Use of custom domains requires the 'CustomAvailability' feature.
+  if (domain->isCustom() && !hasCustomAvailability) {
+    diags.diagnose(loc, diag::availability_domain_requires_feature, *domain,
+                   "CustomAvailability");
+    return std::nullopt;
+  }
+
+  // Use of the 'Swift' domain requires the 'SwiftRuntimeAvailability' feature.
+  if (!hasSwiftRuntimeAvailability && domain->isSwiftRuntime()) {
+    diags.diagnose(loc, diag::availability_domain_requires_feature, *domain,
+                   "SwiftRuntimeAvailability");
+    return std::nullopt;
+  }
+
+  if (domain->isSwiftLanguageMode()) {
+    // When the 'SwiftRuntimeAvailability' feature is enabled, the 'swift'
+    // domain spelling is deprecated in favor of 'SwiftLanguageMode'.
+    if (hasSwiftRuntimeAvailability && identifier.str() == "swift") {
+      diags
+          .diagnose(loc, diag::availability_domain_renamed, identifier,
+                    "SwiftLanguageMode")
+          .fixItReplace(SourceRange(loc), "SwiftLanguageMode");
     }
 
-    if (domain->isSwiftLanguageMode()) {
-      // 'swift' -> 'SwiftLanguageMode'
-      if (hasSwiftRuntimeAvailability && identifier.str() == "swift") {
-        diags
-            .diagnose(loc, diag::availability_domain_renamed, identifier,
-                      "SwiftLanguageMode")
-            .fixItReplace(SourceRange(loc), "SwiftLanguageMode");
-      }
-
-      if (!hasSwiftRuntimeAvailability &&
-          identifier.str() == "SwiftLanguageMode") {
-        // This diagnostic ("Swift requires '-enable-experimental-feature
-        // SwiftRuntimeAvailability'") is confusing but it's also temporary,
-        // assuming the experimental feature becomes official.
-        diags.diagnose(loc, diag::availability_domain_requires_feature, *domain,
-                       "SwiftRuntimeAvailability");
-        return std::nullopt;
-      }
+    // Use of the 'SwiftLanguageMode' domain spelling requires the
+    // 'SwiftRuntimeAvailability' feature.
+    if (!hasSwiftRuntimeAvailability &&
+        identifier.str() == "SwiftLanguageMode") {
+      diags.diagnose(loc, diag::availability_domain_requires_feature, *domain,
+                     "SwiftRuntimeAvailability");
+      return std::nullopt;
     }
   }
 

lib/AST/AvailabilityQuery.cpp

@@ -133,6 +133,7 @@ FuncDecl *AvailabilityQuery::getDynamicQueryDeclAndArguments(
   switch (domain.getKind()) {
   case AvailabilityDomain::Kind::Universal:
   case AvailabilityDomain::Kind::SwiftLanguageMode:
+  case AvailabilityDomain::Kind::SwiftRuntime:
   case AvailabilityDomain::Kind::PackageDescription:
   case AvailabilityDomain::Kind::Embedded:
     return nullptr;

lib/AST/AvailabilityScopeBuilder.cpp

@@ -869,11 +869,12 @@ class AvailabilityScopeBuilder : private ASTWalker {
       return AvailabilityQuery::dynamic(variantSpec->getDomain(), primaryRange,
                                         variantRange);
 
+    case AvailabilityDomain::Kind::SwiftRuntime:
     case AvailabilityDomain::Kind::Platform:
-      // Platform checks are always dynamic. The SIL optimizer is responsible
-      // eliminating these checks when it can prove that they can never fail
-      // (due to the deployment target). We can't perform that analysis here
-      // because it may depend on inlining.
+      // Platform and Swift runtime checks are always dynamic. The SIL optimizer
+      // is responsible eliminating these checks when it can prove that they can
+      // never fail (due to the deployment target). We can't perform that
+      // analysis here because it may depend on inlining.
       return AvailabilityQuery::dynamic(domain, primaryRange, variantRange);
     case AvailabilityDomain::Kind::Custom:
       auto customDomain = domain.getCustomDomain();

lib/Frontend/CompilerInvocation.cpp

@@ -1046,6 +1046,15 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     // HadError = true;
   }
 
+  if (auto A = Args.getLastArg(OPT_min_swift_runtime_version)) {
+    if (auto vers = VersionParser::parseVersionString(A->getValue(),
+                                                      SourceLoc(), &Diags)) {
+      Opts.MinSwiftRuntimeVersion = *vers;
+    } else {
+      return true;
+    }
+  }
+
   if (auto A = Args.getLastArg(OPT_package_description_version)) {
     auto vers =
         VersionParser::parseVersionString(A->getValue(), SourceLoc(), &Diags);

lib/Sema/MiscDiagnostics.cpp

@@ -5131,7 +5131,7 @@ static bool diagnoseAvailabilityCondition(PoundAvailableInfo *info,
       info->isUnavailability() ? "#unavailable" : "#available";
 
   bool hasValidSpecs = false;
-  bool allValidSpecsArePlatform = true;
+  bool wildcardRequiredInList = false;
   std::optional<SourceLoc> wildcardLoc;
   llvm::SmallSet<AvailabilityDomain, 8> seenDomains;
   for (auto spec : info->getSemanticAvailabilitySpecs(DC)) {
@@ -5144,14 +5144,15 @@ static bool diagnoseAvailabilityCondition(PoundAvailableInfo *info,
     auto domain = spec.getDomain();
     auto loc = parsedSpec->getStartLoc();
     bool hasVersion = !spec.getVersion().empty();
+    bool mustBeSpecifiedAlone = domain.mustBeSpecifiedAlone();
 
     if (!domain.supportsQueries()) {
       diags.diagnose(loc, diag::availability_query_not_allowed, domain,
                      hasVersion, queryName);
       return true;
     }
 
-    if (!domain.isPlatform() && info->getQueries().size() > 1) {
+    if (mustBeSpecifiedAlone && info->getQueries().size() > 1) {
       diags.diagnose(loc, diag::availability_must_occur_alone, domain,
                      hasVersion);
       return true;
@@ -5199,8 +5200,8 @@ static bool diagnoseAvailabilityCondition(PoundAvailableInfo *info,
     }
 
     hasValidSpecs = true;
-    if (!domain.isPlatform())
-      allValidSpecsArePlatform = false;
+    if (!mustBeSpecifiedAlone)
+      wildcardRequiredInList = true;
   }
 
   if (info->isUnavailability()) {
@@ -5210,7 +5211,7 @@ static bool diagnoseAvailabilityCondition(PoundAvailableInfo *info,
                     diag::unavailability_query_wildcard_not_required)
           .fixItRemove(*wildcardLoc);
     }
-  } else if (!wildcardLoc && hasValidSpecs && allValidSpecsArePlatform) {
+  } else if (!wildcardLoc && hasValidSpecs && wildcardRequiredInList) {
     if (info->getQueries().size() > 0) {
       auto insertLoc = info->getQueries().back()->getSourceRange().End;
       diags.diagnose(insertLoc, diag::availability_query_wildcard_required)