Merge pull request #70871 from hborla/fix-complete-concurrency-flags

[Concurrency] Promote `StrictConcurrency` to an upcoming feature flag.

Author: hborla

include/swift/Basic/Features.def

@@ -117,7 +117,7 @@ SUPPRESSIBLE_LANGUAGE_FEATURE(Extern, 0, "@_extern")
 
 UPCOMING_FEATURE(ConciseMagicFile, 274, 6)
 UPCOMING_FEATURE(ForwardTrailingClosures, 286, 6)
-UPCOMING_FEATURE(CompleteConcurrency, 0337, 6)
+UPCOMING_FEATURE(StrictConcurrency, 0337, 6)
 UPCOMING_FEATURE(BareSlashRegexLiterals, 354, 6)
 UPCOMING_FEATURE(DeprecateApplicationMain, 383, 6)
 UPCOMING_FEATURE(ImportObjcForwardDeclarations, 384, 6)
@@ -216,9 +216,6 @@ EXPERIMENTAL_FEATURE(ReferenceBindings, true)
 /// Enable the explicit 'import Builtin' and allow Builtin usage.
 EXPERIMENTAL_FEATURE(BuiltinModule, true)
 
-// Enable strict concurrency.
-EXPERIMENTAL_FEATURE(StrictConcurrency, true)
-
 /// Region Based Isolation testing using the TransferNonSendable pass
 EXPERIMENTAL_FEATURE(RegionBasedIsolation, false)
 

lib/AST/ASTPrinter.cpp

@@ -3483,10 +3483,6 @@ static bool usesFeatureForwardTrailingClosures(Decl *decl) {
   return false;
 }
 
-static bool usesFeatureCompleteConcurrency(Decl *decl) {
-  return false;
-}
-
 static bool usesFeatureBareSlashRegexLiterals(Decl *decl) {
   return false;
 }

lib/Frontend/CompilerInvocation.cpp

@@ -808,20 +808,10 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     if (value.startswith("StrictConcurrency")) {
       auto decomposed = value.split("=");
       if (decomposed.first == "StrictConcurrency") {
-        bool handled;
         if (decomposed.second == "") {
           Opts.StrictConcurrencyLevel = StrictConcurrency::Complete;
-          handled = true;
         } else if (auto level = parseStrictConcurrency(decomposed.second)) {
           Opts.StrictConcurrencyLevel = *level;
-          handled = true;
-        } else {
-          handled = false;
-        }
-
-        if (handled) {
-          Opts.enableFeature(Feature::StrictConcurrency);
-          continue;
         }
       }
     }
@@ -876,14 +866,6 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     Opts.enableFeature(*feature);
   }
 
-  // CompleteConcurrency enables all data-race safety upcoming features.
-  if (Opts.hasFeature(Feature::CompleteConcurrency)) {
-    Opts.StrictConcurrencyLevel = StrictConcurrency::Complete;
-    Opts.enableFeature(Feature::DisableOutwardActorInference);
-    Opts.enableFeature(Feature::IsolatedDefaultValues);
-    Opts.enableFeature(Feature::GlobalConcurrency);
-  }
-
   // 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_static_assert))
@@ -1001,7 +983,7 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
                    "-warn-swift3-objc-inference-complete");
 
   // Swift 6+ uses the strictest concurrency level.
-  if (Opts.isSwiftVersionAtLeast(6)) {
+  if (Opts.hasFeature(Feature::StrictConcurrency)) {
     Opts.StrictConcurrencyLevel = StrictConcurrency::Complete;
   } else if (const Arg *A = Args.getLastArg(OPT_strict_concurrency)) {
     if (auto value = parseStrictConcurrency(A->getValue()))
@@ -1012,17 +994,24 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
 
   } else if (Args.hasArg(OPT_warn_concurrency)) {
     Opts.StrictConcurrencyLevel = StrictConcurrency::Complete;
-  } else if (Opts.hasFeature(Feature::CompleteConcurrency) ||
-             Opts.hasFeature(Feature::StrictConcurrency)) {
-    // Already set above.
   } else {
     // Default to minimal checking in Swift 5.x.
-    Opts.StrictConcurrencyLevel = StrictConcurrency::Minimal;
+  }
+
+  // Make sure StrictConcurrency, StrictConcurrency=complete and
+  // -strict-concurrency=complete all mean the same thing.
+  //
+  // The compiler implementation should standardize on StrictConcurrencyLevel,
+  // but if there is any check for `Feature::StrictConcurrency`, the result
+  // should be the same regardless of which flag was used to enable it.
+  if (Opts.StrictConcurrencyLevel == StrictConcurrency::Complete) {
+    Opts.enableFeature(Feature::StrictConcurrency);
   }
 
   // StrictConcurrency::Complete enables all data-race safety features.
   if (Opts.StrictConcurrencyLevel == StrictConcurrency::Complete) {
     Opts.enableFeature(Feature::IsolatedDefaultValues);
+    Opts.enableFeature(Feature::GlobalConcurrency);
   }
 
   Opts.WarnImplicitOverrides =

test/Concurrency/Inputs/sendable_cycle_other.swift

@@ -1,3 +1,3 @@
 struct Foo {
-  static let member = Bar()
+  static let member = Bar() // expected-complete-warning {{static property 'member' is not concurrency-safe because it is not either conforming to 'Sendable' or isolated to a global actor; this is an error in Swift 6}}
 }

test/Concurrency/actor_inout_isolation.swift

@@ -43,7 +43,7 @@ actor TestActor {
 }
 
 @available(SwiftStdlib 5.1, *)
-func modifyAsynchronously(_ foo: inout Int) async { foo += 1 }
+@Sendable func modifyAsynchronously(_ foo: inout Int) async { foo += 1 }
 @available(SwiftStdlib 5.1, *)
 enum Container {
   static let modifyAsyncValue = modifyAsynchronously
@@ -321,4 +321,4 @@ actor ProtectDictionary {
     // expected-warning@-1 {{cannot call mutating async function 'mutate()' on actor-isolated property 'dict'; this is an error in Swift 6}}
     // expected-targeted-complete-warning@-2 {{passing argument of non-sendable type 'inout Optional<Int>' outside of actor-isolated context may introduce data races}}
   }
-}
+}

test/Concurrency/actor_isolation.swift

@@ -11,6 +11,9 @@
 import OtherActors // expected-warning{{add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'OtherActors'}}{{1-1=@preconcurrency }}
 
 let immutableGlobal: String = "hello"
+
+// expected-warning@+2 {{var 'mutableGlobal' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in Swift 6}}
+// expected-note@+1 {{isolate 'mutableGlobal' to a global actor, or convert it to a 'let' constant and conform it to 'Sendable'}}
 var mutableGlobal: String = "can't touch this" // expected-note 5{{var declared here}}
 
 @available(SwiftStdlib 5.1, *)

test/Concurrency/complete_concurrency.swift

@@ -8,15 +8,19 @@ class GlobalCounter {
   var counter: Int = 0
 }
 
-let rs = GlobalCounter()
-var globalInt = 17 // expected-note 2{{var declared here}}
+let rs = GlobalCounter() // expected-warning {{let 'rs' is not concurrency-safe because it is not either conforming to 'Sendable' or isolated to a global actor; this is an error in Swift 6}}
+
+var globalInt = 17 // expected-warning {{var 'globalInt' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in Swift 6}}
+// expected-note@-1 {{isolate 'globalInt' to a global actor, or convert it to a 'let' constant and conform it to 'Sendable'}}
+// expected-note@-2 2{{var declared here}}
+
 
 class MyError: Error { // expected-warning{{non-final class 'MyError' cannot conform to 'Sendable'; use '@unchecked Sendable'}}
   var storage = 0 // expected-warning{{stored property 'storage' of 'Sendable'-conforming class 'MyError' is mutable}}
 }
 
 func testWarnings() {
-  _ = rs // TODO: warn here
+  _ = rs
   _ = globalInt // expected-warning{{reference to var 'globalInt' is not concurrency-safe because it involves shared mutable state}}
   globalInt += 1 // expected-warning{{reference to var 'globalInt' is not concurrency-safe because it involves shared mutable state}}
 }

test/Concurrency/concurrency_warnings.swift

@@ -271,7 +271,8 @@ typealias CF = @Sendable () -> NotConcurrent?
 typealias BadGenericCF<T> = @Sendable () -> T?
 typealias GoodGenericCF<T: Sendable> = @Sendable () -> T? // okay
 
-var concurrentFuncVar: (@Sendable (NotConcurrent) -> Void)? = nil
+var concurrentFuncVar: (@Sendable (NotConcurrent) -> Void)? = nil // expected-warning{{var 'concurrentFuncVar' is not concurrency-safe because it is non-isolated global shared mutable state; this is an error in Swift 6}}
+// expected-note@-1 {{isolate 'concurrentFuncVar' to a global actor, or convert it to a 'let' constant and conform it to 'Sendable'}}
 
 // ----------------------------------------------------------------------
 // Sendable restriction on @Sendable closures.

test/Concurrency/concurrent_value_checking.swift

@@ -1,6 +1,7 @@
 // RUN: %target-swift-frontend -disable-availability-checking -enable-experimental-feature StrictConcurrency -emit-sil -o /dev/null -verify %s
 // RUN: %target-swift-frontend -disable-availability-checking -enable-experimental-feature StrictConcurrency=complete -emit-sil -o /dev/null -verify %s
-// RUN: %target-swift-frontend -disable-availability-checking -enable-experimental-feature StrictConcurrency=complete -emit-sil -o /dev/null -verify -verify-additional-prefix region-isolation- -enable-experimental-feature RegionBasedIsolation %s
+// RUN: %target-swift-frontend -disable-availability-checking -enable-upcoming-feature StrictConcurrency -emit-sil -o /dev/null -verify %s
+// RUN: %target-swift-frontend -disable-availability-checking -enable-upcoming-feature StrictConcurrency -emit-sil -o /dev/null -verify -verify-additional-prefix region-isolation- -enable-experimental-feature RegionBasedIsolation %s
 
 // REQUIRES: concurrency
 // REQUIRES: asserts