[Concurrency] Stage in new Async{Throwing}Stream.init(unfolding:) errors

as warnings.

Marking the closure parameter to these inits as `@Sendable` changed the
inferred isolation of closure arguments in actor-isolated contexts, which
caused new effects checker errors when accessing isolated properties and
methods without `await`. Mark these `init`s as `@preconcurrency`, and fix
the effects checker to downgrade those errors to warnings when the context
of the call is `@preconcurrency`.

Author: hborla

lib/Sema/TypeCheckEffects.cpp

@@ -1183,14 +1183,21 @@ class ApplyClassifier {
     return Classification();
   }
 
+  bool isContextPreconcurrency() const {
+    if (!DC)
+      return false;
+
+    return getActorIsolationOfContext(DC).preconcurrency();
+  }
+
   /// Whether a missing 'await' error on accessing an async var should be
   /// downgraded to a warning.
   ///
   /// Missing 'await' errors are downgraded for synchronous access to isolated
   /// global or static 'let' variables, which was previously accepted in
   /// compiler versions before 5.10, or for declarations marked preconcurrency.
   bool downgradeAsyncAccessToWarning(Decl *decl) {
-    if (decl->preconcurrency()) {
+    if (decl->preconcurrency() || isContextPreconcurrency()) {
       return true;
     }
 
@@ -1339,7 +1346,8 @@ class ApplyClassifier {
 
     // Downgrade missing 'await' errors for preconcurrency references.
     result.setDowngradeToWarning(
-        result.hasAsync() && fnRef.isPreconcurrency());
+        result.hasAsync() &&
+        (fnRef.isPreconcurrency() || isContextPreconcurrency()));
 
     auto classifyApplyEffect = [&](EffectKind kind) {
       if (!fnType->hasEffect(kind) &&

stdlib/public/Concurrency/AsyncStream.swift

@@ -330,21 +330,10 @@ public struct AsyncStream<Element> {
   ///     }
   ///
   ///
-  @_alwaysEmitIntoClient
+  @preconcurrency
   public init(
     unfolding produce: @escaping @Sendable () async -> Element?,
     onCancel: (@Sendable () -> Void)? = nil
-  ) {
-    self.init(
-      unfolding: produce as () async -> Element?,
-      onCancel: onCancel
-    )
-  }
-
-  @usableFromInline
-  internal init(
-    unfolding produce: @escaping () async -> Element?,
-    onCancel: (@Sendable () -> Void)? = nil
   ) {
     let storage: _AsyncStreamCriticalStorage<Optional<() async -> Element?>>
       = .create(produce)

stdlib/public/Concurrency/AsyncThrowingStream.swift

@@ -369,18 +369,9 @@ public struct AsyncThrowingStream<Element, Failure: Error> {
   ///         print(error)
   ///     }
   ///
-  @_alwaysEmitIntoClient
+  @preconcurrency
   public init(
     unfolding produce: @escaping @Sendable () async throws -> Element?
-  ) where Failure == Error {
-    self.init(
-      unfolding: produce as () async throws -> Element?
-    )
-  }
-
-  @usableFromInline
-  internal init(
-    unfolding produce: @escaping () async throws -> Element?
   ) where Failure == Error {
     let storage: _AsyncStreamCriticalStorage<Optional<() async throws -> Element?>>
       = .create(produce)

test/Concurrency/sendable_checking.swift

@@ -377,3 +377,32 @@ final class UseNonisolatedUnsafe: Sendable {
     }
   }
 }
+
+@available(SwiftStdlib 5.1, *)
+@preconcurrency
+func preconcurrencyContext(_: @escaping @Sendable () -> Void) {}
+
+@available(SwiftStdlib 5.1, *)
+@MainActor
+struct DowngradeForPreconcurrency {
+  func capture(completion: @escaping @MainActor () -> Void) {
+    preconcurrencyContext {
+      Task {
+        completion()
+        // expected-warning@-1 2 {{capture of 'completion' with non-sendable type '@MainActor () -> Void' in a `@Sendable` closure; this is an error in the Swift 6 language mode}}
+        // expected-note@-2 2 {{a function type must be marked '@Sendable' to conform to 'Sendable'}}
+        // expected-warning@-3 {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
+        // expected-note@-4 {{calls to parameter 'completion' from outside of its actor context are implicitly asynchronous}}
+      }
+    }
+  }
+
+  var x: Int
+  func createStream() -> AsyncStream<Int> {
+    AsyncStream<Int> {
+      self.x
+      // expected-warning@-1 {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
+      // expected-note@-2 {{property access is 'async'}}
+    }
+  }
+}