[AST][IRGen] Add -min-runtime-version option and IRGen support code.

Add a `-min-runtime-version` option that can be used to avoid problems
when building on Linux and Windows where because the runtime isn't
part of the OS, availability doesn't solve the problem of trying to
build the compiler against an older runtime.

Also add functions to IRGen to make it easy to test feature
availability using both the runtime version and the existing Darwin
availability support.

rdar://121522431

Author: al45tair

include/swift/AST/Availability.h

@@ -238,11 +238,15 @@ class AvailabilityContext {
 
   /// Creates a context that imposes the constraints of the ASTContext's
   /// deployment target.
-  static AvailabilityContext forDeploymentTarget(ASTContext &Ctx);
+  static AvailabilityContext forDeploymentTarget(const ASTContext &Ctx);
 
   /// Creates a context that imposes the constraints of the ASTContext's
   /// inlining target (i.e. minimum inlining version).
-  static AvailabilityContext forInliningTarget(ASTContext &Ctx);
+  static AvailabilityContext forInliningTarget(const ASTContext &Ctx);
+
+  /// Creates a context that imposes the constraints of the ASTContext's
+  /// minimum runtime version.
+  static AvailabilityContext forRuntimeTarget(const ASTContext &Ctx);
 
   /// Creates a context that imposes no constraints.
   ///

include/swift/Basic/LangOptions.h

@@ -174,6 +174,9 @@ namespace swift {
     /// User-overridable language version to compile for.
     version::Version EffectiveLanguageVersion = version::Version::getCurrentLanguageVersion();
 
+    /// Swift runtime version to compile for.
+    version::Version RuntimeVersion = version::Version::getCurrentLanguageVersion();
+
     /// PackageDescription version to compile for.
     version::Version PackageDescriptionVersion;
 

include/swift/Basic/Version.h

@@ -64,6 +64,9 @@ class Version {
   /// Create a literal version from a list of components.
   Version(std::initializer_list<unsigned> Values) : Components(Values) {}
 
+  /// Create a version from an llvm::VersionTuple.
+  Version(const llvm::VersionTuple &version);
+
   /// Return a string to be used as an internal preprocessor define.
   ///
   /// The components of the version are multiplied element-wise by

include/swift/Option/Options.td

@@ -1349,6 +1349,11 @@ def min_inlining_target_version : Separate<["-"], "target-min-inlining-version">
   HelpText<"Require inlinable code with no '@available' attribute to back-deploy "
            "to this version of the '-target' OS">;
 
+def min_runtime_version : Separate<["-"], "min-runtime-version">,
+  Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
+  HelpText<"Specify the minimum runtime version to build force on non-Darwin "
+           "systems">;
+
 def profile_generate : Flag<["-"], "profile-generate">,
   Flags<[FrontendOption, NoInteractiveOption]>,
   HelpText<"Generate instrumented code to collect execution counts">;

lib/AST/Availability.cpp

@@ -28,16 +28,21 @@
 
 using namespace swift;
 
-AvailabilityContext AvailabilityContext::forDeploymentTarget(ASTContext &Ctx) {
+AvailabilityContext AvailabilityContext::forDeploymentTarget(const ASTContext &Ctx) {
   return AvailabilityContext(
       VersionRange::allGTE(Ctx.LangOpts.getMinPlatformVersion()));
 }
 
-AvailabilityContext AvailabilityContext::forInliningTarget(ASTContext &Ctx) {
+AvailabilityContext AvailabilityContext::forInliningTarget(const ASTContext &Ctx) {
   return AvailabilityContext(
       VersionRange::allGTE(Ctx.LangOpts.MinimumInliningTargetVersion));
 }
 
+AvailabilityContext AvailabilityContext::forRuntimeTarget(const ASTContext &Ctx) {
+  return AvailabilityContext(
+    VersionRange::allGTE(Ctx.LangOpts.RuntimeVersion));
+}
+
 namespace {
 
 /// The inferred availability required to access a group of declarations

lib/Basic/Version.cpp

@@ -100,6 +100,23 @@ Version::preprocessorDefinition(StringRef macroName,
   return define;
 }
 
+Version::Version(const llvm::VersionTuple &version) {
+  if (version.empty())
+    return;
+
+  Components.emplace_back(version.getMajor());
+
+  if (auto minor = version.getMinor()) {
+    Components.emplace_back(*minor);
+    if (auto subminor = version.getSubminor()) {
+      Components.emplace_back(*subminor);
+      if (auto build = version.getBuild()) {
+        Components.emplace_back(*build);
+      }
+    }
+  }
+}
+
 Version::operator llvm::VersionTuple() const
 {
   switch (Components.size()) {

lib/Frontend/CompilerInvocation.cpp

@@ -1213,6 +1213,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     // FIXME: Should we diagnose if it's below the default?
     Opts.MinimumInliningTargetVersion = *vers;
 
+  if (auto vers = parseVersionArg(OPT_min_runtime_version))
+    Opts.RuntimeVersion = version::Version(*vers);
+
   if (auto vers = parseVersionArg(OPT_target_sdk_version))
     Opts.SDKVersion = *vers;
 

lib/IRGen/IRGenModule.cpp

@@ -1998,6 +1998,20 @@ void IRGenModule::error(SourceLoc loc, const Twine &message) {
 
 bool IRGenModule::useDllStorage() { return ::useDllStorage(Triple); }
 
+#define FEATURE(N, V)                                                   \
+bool IRGenModule::is##N##FeatureAvailable(const ASTContext &context) {  \
+  auto deploymentAvailability                                           \
+    = AvailabilityContext::forDeploymentTarget(context);                \
+  auto runtimeAvailability                                              \
+    = AvailabilityContext::forRuntimeTarget(context);                   \
+  return deploymentAvailability.isContainedIn(                          \
+    context.get##N##Availability())                                     \
+    && runtimeAvailability.isContainedIn(                               \
+      context.get##N##RuntimeAvailability());                           \
+}
+
+#include "swift/AST/FeatureAvailability.def"
+
 bool IRGenModule::shouldPrespecializeGenericMetadata() {
   auto canPrespecializeTarget =
       (Triple.isOSDarwin() || Triple.isOSWindows() ||
@@ -2017,11 +2031,9 @@ bool IRGenModule::shouldPrespecializeGenericMetadata() {
 bool IRGenModule::canUseObjCSymbolicReferences() {
   if (!IRGen.Opts.EnableObjectiveCProtocolSymbolicReferences)
     return false;
-  auto &context = getSwiftModule()->getASTContext();
-  auto deploymentAvailability =
-      AvailabilityContext::forDeploymentTarget(context);
-  return deploymentAvailability.isContainedIn(
-      context.getObjCSymbolicReferencesAvailability());
+  return isObjCSymbolicReferencesFeatureAvailable(
+    getSwiftModule()->getASTContext()
+  );
 }
 
 bool IRGenModule::canMakeStaticObjectReadOnly(SILType objectType) {
@@ -2043,7 +2055,7 @@ bool IRGenModule::canMakeStaticObjectReadOnly(SILType objectType) {
   if (clDecl->getNameStr() != "_ContiguousArrayStorage")
     return false;
 
-  if (!getAvailabilityContext().isContainedIn(Context.getStaticReadOnlyArraysAvailability()))
+  if (!isStaticReadOnlyArraysFeatureAvailable())
     return false;
 
   if (!getStaticArrayStorageDecl())

lib/IRGen/IRGenModule.h

@@ -934,6 +934,13 @@ class IRGenModule {
 
   ClassDecl *getStaticArrayStorageDecl();
 
+#define FEATURE(N, V)                                           \
+  bool is##N##FeatureAvailable(const ASTContext &context);      \
+  inline bool is##N##FeatureAvailable() {                       \
+    return is##N##FeatureAvailable(Context);                    \
+  }
+  #include "swift/AST/FeatureAvailability.def"
+
   bool canUseObjCSymbolicReferences();
 
   Size getAtomicBoolSize() const { return AtomicBoolSize; }