Refactor bare slash regex literals as a future feature

Author: DougGregor

include/swift/Basic/Features.def

@@ -91,6 +91,7 @@ SUPPRESSIBLE_LANGUAGE_FEATURE(NoAsyncAvailability, 340, "@available(*, noasync)"
 
 FUTURE_FEATURE(ConciseMagicFile, 274, 6)
 FUTURE_FEATURE(ForwardTrailingClosures, 286, 6)
+FUTURE_FEATURE(BareSlashRegexLiterals, 354, 6)
 
 EXPERIMENTAL_FEATURE(StaticAssert)
 EXPERIMENTAL_FEATURE(VariadicGenerics)

include/swift/Basic/LangOptions.h

@@ -529,10 +529,6 @@ namespace swift {
     /// Enables dumping type witness systems from associated type inference.
     bool DumpTypeWitnessSystems = false;
 
-    /// Enables `/.../` syntax regular-expression literals. This requires
-    /// experimental string processing. Note this does not affect `#/.../#`.
-    bool EnableBareSlashRegexLiterals = false;
-
     /// Sets the target we are building for and updates platform conditions
     /// to match.
     ///

lib/AST/ASTPrinter.cpp

@@ -3003,6 +3003,14 @@ static bool usesFeatureConciseMagicFile(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureForwardTrailingClosures(Decl *decl) {
+  return false;
+}
+
+static bool usesFeatureBareSlashRegexLiterals(Decl *decl) {
+  return false;
+}
+
 static bool usesFeatureVariadicGenerics(Decl *decl) {
   return false;
 }
@@ -3027,10 +3035,6 @@ static bool usesFeatureTypeWitnessSystemInference(Decl *decl) {
   return false;
 }
 
-static bool usesFeatureForwardTrailingClosures(Decl *decl) {
-  return false;
-}
-
 static void
 suppressingFeatureNoAsyncAvailability(PrintOptions &options,
                                       llvm::function_ref<void()> action) {

lib/Frontend/CompilerInvocation.cpp

@@ -486,25 +486,6 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
       = A->getOption().matches(OPT_enable_deserialization_recovery);
   }
 
-  // Whether '/.../' regex literals are enabled. This implies experimental
-  // string processing.
-  if (Args.hasArg(OPT_enable_bare_slash_regex)) {
-    Opts.EnableBareSlashRegexLiterals = true;
-    Opts.EnableExperimentalStringProcessing = true;
-  }
-
-  // Experimental string processing.
-  if (auto A = Args.getLastArg(OPT_enable_experimental_string_processing,
-                               OPT_disable_experimental_string_processing)) {
-    Opts.EnableExperimentalStringProcessing =
-        A->getOption().matches(OPT_enable_experimental_string_processing);
-
-    // When experimental string processing is explicitly disabled, also disable
-    // forward slash regex `/.../`.
-    if (!Opts.EnableExperimentalStringProcessing)
-      Opts.EnableBareSlashRegexLiterals = false;
-  }
-
   Opts.EnableExperimentalBoundGenericExtensions |=
     Args.hasArg(OPT_enable_experimental_bound_generic_extensions);
 
@@ -632,6 +613,12 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     Opts.addCustomConditionalCompilationFlag(A->getValue());
   }
 
+  // Determine whether string processing is enabled
+  Opts.EnableExperimentalStringProcessing =
+    Args.hasFlag(OPT_enable_experimental_string_processing,
+                 OPT_disable_experimental_string_processing,
+                 Args.hasArg(OPT_enable_bare_slash_regex));
+
   // Add a future feature if it is not already implied by the language version.
   auto addFutureFeatureIfNotImplied = [&](Feature feature) {
     // Check if this feature was introduced already in this language version.
@@ -646,6 +633,8 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   // Map historical flags over to future features.
   if (Args.hasArg(OPT_enable_experimental_concise_pound_file))
     addFutureFeatureIfNotImplied(Feature::ConciseMagicFile);
+  if (Args.hasArg(OPT_enable_bare_slash_regex))
+    addFutureFeatureIfNotImplied(Feature::BareSlashRegexLiterals);
 
   for (const Arg *A : Args.filtered(OPT_enable_experimental_feature)) {
     // If this is a known experimental feature, allow it in +Asserts

lib/Parse/ParseExpr.cpp

@@ -881,7 +881,8 @@ UnresolvedDeclRefExpr *Parser::parseExprOperator() {
 }
 
 void Parser::tryLexRegexLiteral(bool forUnappliedOperator) {
-  if (!Context.LangOpts.EnableBareSlashRegexLiterals)
+  if (!Context.LangOpts.hasFeature(Feature::BareSlashRegexLiterals) ||
+      !Context.LangOpts.EnableExperimentalStringProcessing)
     return;
 
   // Check to see if we have a regex literal `/.../`, optionally with a prefix

tools/libSwiftSyntaxParser/libSwiftSyntaxParser.cpp

@@ -512,9 +512,7 @@ swiftparse_client_node_t SynParser::parse(const char *source, size_t len) {
 
   // Always enable bare /.../ regex literal in syntax parser.
   langOpts.EnableExperimentalStringProcessing = true;
-  if (EnableBareSlashRegexLiteral && *EnableBareSlashRegexLiteral) {
-    langOpts.EnableBareSlashRegexLiterals = true;
-  }
+  langOpts.Features.insert(Feature::BareSlashRegexLiterals);
   if (EffectiveLanguageVersion) {
     langOpts.EffectiveLanguageVersion = *EffectiveLanguageVersion;
   }

tools/swift-ide-test/swift-ide-test.cpp

@@ -4305,7 +4305,7 @@ int main(int argc, char *argv[]) {
     InitInvok.getLangOptions().EnableExperimentalStringProcessing = true;
   }
   if (options::EnableBareSlashRegexLiterals) {
-    InitInvok.getLangOptions().EnableBareSlashRegexLiterals = true;
+    InitInvok.getLangOptions().Features.insert(Feature::BareSlashRegexLiterals);
     InitInvok.getLangOptions().EnableExperimentalStringProcessing = true;
   }
 

tools/swift-syntax-test/swift-syntax-test.cpp

@@ -592,7 +592,7 @@ int parseFile(
   Invocation.getLangOptions().VerifySyntaxTree = options::VerifySyntaxTree;
   Invocation.getLangOptions().DisablePoundIfEvaluation = true;
   Invocation.getLangOptions().EnableExperimentalStringProcessing = true;
-  Invocation.getLangOptions().EnableBareSlashRegexLiterals = true;
+  Invocation.getLangOptions().Features.insert(Feature::BareSlashRegexLiterals);
 
   Invocation.getFrontendOptions().InputsAndOutputs.addInputFile(InputFileName);