Add -enable-upcoming-feature X command-line argument.

Introduce the `-enable-upcoming-feature X` command-line argument to
allow one to opt into features that will be enabled in an upcoming language
mode. Stage in several features this way (`ConciseMagicFile`,
`ForwardTrailingClosures`, `BareSlashRegexLiterals`).

Author: DougGregor

include/swift/AST/DiagnosticsFrontend.def

@@ -40,6 +40,10 @@ ERROR(error_experimental_feature_not_available, none,
       "experimental feature '%0' cannot be enabled in a production compiler",
       (StringRef))
 
+ERROR(error_upcoming_feature_on_by_default, none,
+      "upcoming feature '%0' is already enabled as of Swift version %1",
+      (StringRef, unsigned))
+
 ERROR(error_unknown_library_level, none,
       "unknown library level '%0', "
       "expected one of 'api', 'spi' or 'other'", (StringRef))

include/swift/Basic/Feature.h

@@ -53,7 +53,7 @@ inline bool featureImpliesFeature(Feature feature, Feature implied) {
 }
 
 /// Get the feature corresponding to this "future" feature, if there is one.
-llvm::Optional<Feature> getFutureFeature(llvm::StringRef name);
+llvm::Optional<Feature> getUpcomingFeature(llvm::StringRef name);
 
 /// Get the feature corresponding to this "experimental" feature, if there is
 /// one.

include/swift/Basic/Features.def

@@ -48,8 +48,8 @@
   LANGUAGE_FEATURE(FeatureName, SENumber, Description, Option)
 #endif
 
-#ifndef FUTURE_FEATURE
-#  define FUTURE_FEATURE(FeatureName, SENumber, Version)   \
+#ifndef UPCOMING_FEATURE
+#  define UPCOMING_FEATURE(FeatureName, SENumber, Version)   \
      LANGUAGE_FEATURE(FeatureName, SENumber, #FeatureName, \
                       langOpts.hasFeature(#FeatureName))
 #endif
@@ -90,9 +90,9 @@ SUPPRESSIBLE_LANGUAGE_FEATURE(PrimaryAssociatedTypes2, 346, "Primary associated
 SUPPRESSIBLE_LANGUAGE_FEATURE(UnavailableFromAsync, 0, "@_unavailableFromAsync", true)
 SUPPRESSIBLE_LANGUAGE_FEATURE(NoAsyncAvailability, 340, "@available(*, noasync)", true)
 
-FUTURE_FEATURE(ConciseMagicFile, 274, 6)
-FUTURE_FEATURE(ForwardTrailingClosures, 286, 6)
-FUTURE_FEATURE(BareSlashRegexLiterals, 354, 6)
+UPCOMING_FEATURE(ConciseMagicFile, 274, 6)
+UPCOMING_FEATURE(ForwardTrailingClosures, 286, 6)
+UPCOMING_FEATURE(BareSlashRegexLiterals, 354, 6)
 
 EXPERIMENTAL_FEATURE(StaticAssert)
 EXPERIMENTAL_FEATURE(VariadicGenerics)
@@ -118,6 +118,6 @@ EXPERIMENTAL_FEATURE(AdditiveArithmeticDerivedConformances)
 EXPERIMENTAL_FEATURE(SendableCompletionHandlers)
 
 #undef EXPERIMENTAL_FEATURE
-#undef FUTURE_FEATURE
+#undef UPCOMING_FEATURE
 #undef SUPPRESSIBLE_LANGUAGE_FEATURE
 #undef LANGUAGE_FEATURE

include/swift/Basic/LangOptions.h

@@ -28,6 +28,7 @@
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/Regex.h"

include/swift/Option/Options.td

@@ -696,6 +696,11 @@ def enable_experimental_feature :
   Flags<[FrontendOption]>,
   HelpText<"Enable an experimental feature">;
 
+def enable_upcoming_feature : Separate<["-"], "enable-upcoming-feature">,
+  Flags<[FrontendOption]>,
+  HelpText<"Enable a feature that will be introduced in an upcoming language "
+           "version">;
+
 def Rpass_EQ : Joined<["-"], "Rpass=">,
   Flags<[FrontendOption]>,
   HelpText<"Report performed transformations by optimization passes whose "

lib/Basic/LangOptions.cpp

@@ -240,7 +240,7 @@ bool LangOptions::hasFeature(Feature feature) const {
 }
 
 bool LangOptions::hasFeature(llvm::StringRef featureName) const {
-  if (auto feature = getFutureFeature(featureName))
+  if (auto feature = getUpcomingFeature(featureName))
     return hasFeature(*feature);
 
   if (auto feature = getExperimentalFeature(featureName))
@@ -434,10 +434,10 @@ bool swift::isSuppressibleFeature(Feature feature) {
   llvm_unreachable("covered switch");
 }
 
-llvm::Optional<Feature> swift::getFutureFeature(llvm::StringRef name) {
+llvm::Optional<Feature> swift::getUpcomingFeature(llvm::StringRef name) {
   return llvm::StringSwitch<Optional<Feature>>(name)
 #define LANGUAGE_FEATURE(FeatureName, SENumber, Description, Option)
-#define FUTURE_FEATURE(FeatureName, SENumber, Version) \
+#define UPCOMING_FEATURE(FeatureName, SENumber, Version) \
                    .Case(#FeatureName, Feature::FeatureName)
 #include "swift/Basic/Features.def"
                    .Default(None);
@@ -455,7 +455,7 @@ llvm::Optional<Feature> swift::getExperimentalFeature(llvm::StringRef name) {
 llvm::Optional<unsigned> swift::getFeatureLanguageVersion(Feature feature) {
   switch (feature) {
 #define LANGUAGE_FEATURE(FeatureName, SENumber, Description, Option)
-#define FUTURE_FEATURE(FeatureName, SENumber, Version) \
+#define UPCOMING_FEATURE(FeatureName, SENumber, Version) \
   case Feature::FeatureName: return Version;
 #include "swift/Basic/Features.def"
   default: return None;

lib/Driver/ToolChains.cpp

@@ -237,6 +237,7 @@ void ToolChain::addCommonFrontendArgs(const OutputInfo &OI,
   inputArgs.AddLastArg(arguments, options::OPT_warn_concurrency);
   inputArgs.AddLastArg(arguments, options::OPT_strict_concurrency);
   inputArgs.AddAllArgs(arguments, options::OPT_enable_experimental_feature);
+  inputArgs.AddAllArgs(arguments, options::OPT_enable_upcoming_feature);
   inputArgs.AddLastArg(arguments, options::OPT_warn_implicit_overrides);
   inputArgs.AddLastArg(arguments, options::OPT_typo_correction_limit);
   inputArgs.AddLastArg(arguments, options::OPT_enable_app_extension);

lib/Frontend/CompilerInvocation.cpp

@@ -15,6 +15,7 @@
 
 #include "ArgsToFrontendOptionsConverter.h"
 #include "swift/AST/DiagnosticsFrontend.h"
+#include "swift/Basic/Feature.h"
 #include "swift/Basic/Platform.h"
 #include "swift/Option/Options.h"
 #include "swift/Option/SanitizerOptions.h"
@@ -637,6 +638,26 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     }
   }
 
+  // Map historical flags over to future features.
+  for (const Arg *A : Args.filtered(OPT_enable_upcoming_feature)) {
+    // Ignore unknown features.
+    auto feature = getUpcomingFeature(A->getValue());
+    if (!feature)
+      continue;
+
+    // Check if this feature was introduced already in this language version.
+    if (auto firstVersion = getFeatureLanguageVersion(*feature)) {
+      if (Opts.isSwiftVersionAtLeast(*firstVersion)) {
+        Diags.diagnose(SourceLoc(), diag::error_upcoming_feature_on_by_default,
+                       A->getValue(), *firstVersion);
+        continue;
+      }
+    }
+
+    // Add the feature.
+    Opts.Features.insert(*feature);
+  }
+
   // Map historical flags over to experimental features. We do this for all
   // compilers because that's how existing experimental feature flags work.
   if (Args.hasArg(OPT_enable_experimental_variadic_generics))

lib/Parse/ParseIfConfig.cpp

@@ -484,6 +484,7 @@ class EvaluateIfConfigCondition :
     bool isKnownFeature = llvm::StringSwitch<bool>(Name)
 #define LANGUAGE_FEATURE(FeatureName, SENumber, Description, Option) \
         .Case("$" #FeatureName, Option)
+#define UPCOMING_FEATURE(FeatureName, SENumber, Version)
 #include "swift/Basic/Features.def"
         .Default(false);
 

test/Frontend/upcoming_feature.swift

@@ -0,0 +1,9 @@
+
+// It's fine to provide a feature that we don't know about
+// RUN: %target-swift-frontend -typecheck -enable-upcoming-feature UnknownFeature %s
+
+// It's not fine to provide a feature that's in the specified language version.
+// RUN: not %target-swift-frontend -typecheck -enable-upcoming-feature ConciseMagicFile -swift-version 6 %s 2>&1 | %FileCheck %s
+// REQUIRES: asserts
+
+// CHECK: error: upcoming feature 'ConciseMagicFile' is already enabled as of Swift version 6