Merge pull request #84778 from tshortli/swift-runtime-availability-domain

AST: Introduce a Swift runtime availability domain

Author: tshortli

include/swift/AST/Attr.h

@@ -3972,7 +3972,7 @@ class SemanticAvailableAttr final {
 
   /// Whether this is a language mode specific attribute.
   bool isSwiftLanguageModeSpecific() const {
-    return getDomain().isSwiftLanguage() && isVersionSpecific();
+    return getDomain().isSwiftLanguageMode() && isVersionSpecific();
   }
 
   /// Whether this is a PackageDescription version specific attribute.

include/swift/AST/AvailabilityDomain.h

@@ -49,7 +49,10 @@ class AvailabilityDomain final {
     Universal,
 
     /// Represents availability with respect to Swift language mode.
-    SwiftLanguage,
+    SwiftLanguageMode,
+
+    /// Represents availability with respect to the Swift runtime.
+    SwiftRuntime,
 
     /// Represents PackageDescription availability.
     PackageDescription,
@@ -140,8 +143,12 @@ class AvailabilityDomain final {
     return AvailabilityDomain(platformKind);
   }
 
-  static AvailabilityDomain forSwiftLanguage() {
-    return AvailabilityDomain(Kind::SwiftLanguage);
+  static AvailabilityDomain forSwiftLanguageMode() {
+    return AvailabilityDomain(Kind::SwiftLanguageMode);
+  }
+
+  static AvailabilityDomain forSwiftRuntime() {
+    return AvailabilityDomain(Kind::SwiftRuntime);
   }
 
   static AvailabilityDomain forPackageDescription() {
@@ -181,7 +188,11 @@ class AvailabilityDomain final {
 
   bool isPlatform() const { return getKind() == Kind::Platform; }
 
-  bool isSwiftLanguage() const { return getKind() == Kind::SwiftLanguage; }
+  bool isSwiftLanguageMode() const {
+    return getKind() == Kind::SwiftLanguageMode;
+  }
+
+  bool isSwiftRuntime() const { return getKind() == Kind::SwiftRuntime; }
 
   bool isPackageDescription() const {
     return getKind() == Kind::PackageDescription;
@@ -234,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/AST/DiagnosticsSema.def

@@ -6986,6 +6986,12 @@ WARNING(availability_unsupported_version_number, none,
 WARNING(availability_invalid_version_number_for_domain, none,
         "'%0' is not a valid version number for %1",
         (llvm::VersionTuple, AvailabilityDomain))
+WARNING(availability_domain_renamed, none,
+        "%0 has been renamed to '%1'",
+        (Identifier, StringRef))
+ERROR(availability_domain_requires_feature, none,
+      "%0 requires '-enable-experimental-feature %1'",
+      (AvailabilityDomain, StringRef))
 
 WARNING(attr_availability_expected_deprecated_version, none,
        "expected version number with 'deprecated' in '%0' attribute for %1",
@@ -6996,9 +7002,6 @@ WARNING(attr_availability_cannot_be_used_for_domain, none,
 WARNING(attr_availability_expected_version_spec, none,
        "expected 'introduced', 'deprecated', or 'obsoleted' in '%0' attribute "
        "for %1", (const DeclAttribute, AvailabilityDomain))
-ERROR(attr_availability_requires_custom_availability, none,
-      "%0 requires '-enable-experimental-feature CustomAvailability'",
-      (AvailabilityDomain))
 ERROR(attr_availability_domain_access, none,
       "availability domain '%0' is "
       "%select{private|fileprivate|internal|package|%error|%error}1 "

include/swift/Basic/Features.def

@@ -556,6 +556,9 @@ EXPERIMENTAL_FEATURE(BorrowAndMutateAccessors, false)
 /// Allow use of @inline(always) attribute
 SUPPRESSIBLE_EXPERIMENTAL_FEATURE(InlineAlways, false)
 
+/// Allow use of 'Swift' (Swift runtime version) in @available attributes
+EXPERIMENTAL_FEATURE(SwiftRuntimeAvailability, true)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

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/APIDigester/ModuleAnalyzerNodes.cpp

@@ -1380,7 +1380,7 @@ StringRef SDKContext::getLanguageIntroVersion(Decl *D) {
   for (auto attr : D->getSemanticAvailableAttrs()) {
     auto domain = attr.getDomain();
 
-    if (domain.isSwiftLanguage() && attr.getIntroduced()) {
+    if (domain.isSwiftLanguageMode() && attr.getIntroduced()) {
       return buffer(attr.getIntroduced()->getAsString());
     }
   }

lib/AST/Attr.cpp

@@ -978,7 +978,7 @@ static void printAvailableAttr(const Decl *D, const SemanticAvailableAttr &Attr,
   // attributes that are universally unavailable in Swift, we must print them
   // as universally unavailable instead.
   // FIXME: Reconsider this, it's a weird special case.
-  if (Domain.isSwiftLanguage() && Attr.isUnconditionallyUnavailable())
+  if (Domain.isSwiftLanguageMode() && Attr.isUnconditionallyUnavailable())
     Printer << "*";
   else
     Printer << Domain.getNameForAttributePrinting();
@@ -1020,7 +1020,8 @@ static void printAvailableAttr(const Decl *D, const SemanticAvailableAttr &Attr,
   if (!Attr.getMessage().empty()) {
     Printer << ", message: ";
     Printer.printEscapedStringLiteral(Attr.getMessage());
-  } else if (Domain.isSwiftLanguage() && Attr.isUnconditionallyUnavailable())
+  } else if (Domain.isSwiftLanguageMode() &&
+             Attr.isUnconditionallyUnavailable())
     Printer << ", message: \"Not available in Swift\"";
 }
 
@@ -2329,7 +2330,7 @@ AvailableAttr *AvailableAttr::createUnavailableInSwift(ASTContext &C,
                                                        StringRef Message,
                                                        StringRef Rename) {
   return new (C) AvailableAttr(
-      SourceLoc(), SourceRange(), AvailabilityDomain::forSwiftLanguage(),
+      SourceLoc(), SourceRange(), AvailabilityDomain::forSwiftLanguageMode(),
       SourceLoc(), Kind::Unavailable, Message, Rename,
       /*Introduced=*/{}, SourceRange(), /*Deprecated=*/{}, SourceRange(),
       /*Obsoleted=*/{}, SourceRange(),
@@ -2341,7 +2342,7 @@ AvailableAttr *AvailableAttr::createSwiftLanguageModeVersioned(
     ASTContext &C, StringRef Message, StringRef Rename,
     llvm::VersionTuple Introduced, llvm::VersionTuple Obsoleted) {
   return new (C) AvailableAttr(
-      SourceLoc(), SourceRange(), AvailabilityDomain::forSwiftLanguage(),
+      SourceLoc(), SourceRange(), AvailabilityDomain::forSwiftLanguageMode(),
       SourceLoc(), Kind::Default, Message, Rename, Introduced, SourceRange(),
       /*Deprecated=*/{}, SourceRange(), Obsoleted, SourceRange(),
       /*Implicit=*/false,

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->isSwiftLanguage() || domain->isPackageDescription()) {
+  if (domain->isSwiftLanguageMode() || domain->isPackageDescription() ||
+      domain->isSwiftRuntime()) {
     switch (attr->getKind()) {
     case AvailableAttr::Kind::Deprecated:
       diags.diagnose(attrLoc,

lib/AST/AvailabilityConstraint.cpp

@@ -162,7 +162,7 @@ static bool canIgnoreConstraintInUnavailableContexts(
   if (!flags.contains(AvailabilityConstraintFlag::
                       AllowUniversallyUnavailableInCompatibleContexts)) {
     if (!isa<TypeDecl>(decl) && !isa<ExtensionDecl>(decl)) {
-      if (domain.isUniversal() || domain.isSwiftLanguage())
+      if (domain.isUniversal() || domain.isSwiftLanguageMode())
         return false;
     }
   }
@@ -342,7 +342,8 @@ domainCanBeUnconditionallyUnavailableAtRuntime(AvailabilityDomain domain,
       return true;
     return domain.isActive(ctx);
 
-  case AvailabilityDomain::Kind::SwiftLanguage:
+  case AvailabilityDomain::Kind::SwiftLanguageMode:
+  case AvailabilityDomain::Kind::SwiftRuntime:
   case AvailabilityDomain::Kind::PackageDescription:
     return false;
 
@@ -369,7 +370,8 @@ domainIsUnavailableAtRuntimeIfUnintroduced(AvailabilityDomain domain,
   switch (domain.getKind()) {
   case AvailabilityDomain::Kind::Universal:
   case AvailabilityDomain::Kind::Platform:
-  case AvailabilityDomain::Kind::SwiftLanguage:
+  case AvailabilityDomain::Kind::SwiftLanguageMode:
+  case AvailabilityDomain::Kind::SwiftRuntime:
   case AvailabilityDomain::Kind::PackageDescription:
     return false;