Merge pull request #72252 from hborla/concurrency-lib-annotations

[Concurrency] Add a few missing `Sendable` annotations in the concurrency library.

Author: hborla

include/swift/AST/PrintOptions.h

@@ -379,6 +379,9 @@ struct PrintOptions {
   /// Suppress the @isolated(any) attribute.
   bool SuppressIsolatedAny = false;
 
+  /// Suppress 'isolated' and '#isolation' on isolated parameters with optional type.
+  bool SuppressOptionalIsolatedParams = false;
+
   /// List of attribute kinds that should not be printed.
   std::vector<AnyAttrKind> ExcludeAttrList = {
       DeclAttrKind::Transparent, DeclAttrKind::Effects,

include/swift/Basic/Features.def

@@ -164,7 +164,7 @@ LANGUAGE_FEATURE(FreestandingMacros, 397, "freestanding declaration macros")
 SUPPRESSIBLE_LANGUAGE_FEATURE(RetroactiveAttribute, 364, "@retroactive")
 SUPPRESSIBLE_LANGUAGE_FEATURE(ExtensionMacroAttr, 0, "@attached(extension)")
 LANGUAGE_FEATURE(TypedThrows, 413, "Typed throws")
-LANGUAGE_FEATURE(OptionalIsolatedParameters, 420, "Optional isolated parameters")
+CONDITIONALLY_SUPPRESSIBLE_LANGUAGE_FEATURE(OptionalIsolatedParameters, 420, "Optional isolated parameters")
 SUPPRESSIBLE_LANGUAGE_FEATURE(Extern, 0, "@_extern")
 LANGUAGE_FEATURE(ExpressionMacroDefaultArguments, 422, "Expression macro as caller-side default argument")
 LANGUAGE_FEATURE(BuiltinStoreRaw, 0, "Builtin.storeRaw")

lib/AST/ASTPrinter.cpp

@@ -3083,6 +3083,14 @@ static void suppressingFeatureIsolatedAny(PrintOptions &options,
   action();
 }
 
+static void suppressingFeatureOptionalIsolatedParameters(
+    PrintOptions &options,
+    llvm::function_ref<void()> action) {
+  llvm::SaveAndRestore<bool> scope(
+      options.SuppressOptionalIsolatedParams, true);
+  action();
+}
+
 static void suppressingFeatureAssociatedTypeImplements(PrintOptions &options,
                                      llvm::function_ref<void()> action) {
   unsigned originalExcludeAttrCount = options.ExcludeAttrList.size();
@@ -3660,8 +3668,11 @@ static void printParameterFlags(ASTPrinter &printer,
     break;
   }
 
-  if (flags.isIsolated())
-    printer.printKeyword("isolated", options, " ");
+  if (flags.isIsolated()) {
+    if (!(param && param->getInterfaceType()->isOptional() &&
+          options.SuppressOptionalIsolatedParams))
+      printer.printKeyword("isolated", options, " ");
+  }
 
   if (flags.hasResultDependsOn())
     printer.printKeyword("_resultDependsOn", options, " ");
@@ -3809,6 +3820,16 @@ void PrintAST::printOneParameter(const ParamDecl *param,
   }
 
   if (param->isDefaultArgument() && Options.PrintDefaultArgumentValue) {
+    auto defaultArgKind = param->getDefaultArgumentKind();
+    if (param->isIsolated() &&
+        defaultArgKind == DefaultArgumentKind::ExpressionMacro &&
+        Options.SuppressOptionalIsolatedParams) {
+      // If we're suppressing optional isolated parameters, print
+      // 'nil' instead of '#isolation'
+      Printer << " = nil";
+      return;
+    }
+
     Printer.callPrintStructurePre(PrintStructureKind::DefaultArgumentClause);
     SWIFT_DEFER {
       Printer.printStructurePost(PrintStructureKind::DefaultArgumentClause);

stdlib/public/Concurrency/AsyncStream.swift

@@ -330,8 +330,20 @@ public struct AsyncStream<Element> {
   ///     }
   ///
   ///
+  @_alwaysEmitIntoClient
   public init(
-    unfolding produce: @escaping () async -> Element?, 
+    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?>>

stdlib/public/Concurrency/AsyncThrowingStream.swift

@@ -369,7 +369,17 @@ public struct AsyncThrowingStream<Element, Failure: Error> {
   ///         print(error)
   ///     }
   ///
+  @_alwaysEmitIntoClient
   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?>>

stdlib/public/Concurrency/Clock.swift

@@ -67,7 +67,19 @@ extension Clock {
   ///          await someWork()
   ///       }
   @available(SwiftStdlib 5.7, *)
+  @_alwaysEmitIntoClient
+  @_allowFeatureSuppression(OptionalIsolatedParameters)
   public func measure(
+    isolation: isolated (any Actor)? = #isolation,
+    _ work: () async throws -> Void
+  ) async rethrows -> Instant.Duration {
+    try await measure(work)
+  }
+
+  @available(SwiftStdlib 5.7, *)
+  @_unsafeInheritExecutor
+  @usableFromInline
+  internal func measure(
     _ work: () async throws -> Void
   ) async rethrows -> Instant.Duration {
     let start = now

stdlib/public/Concurrency/ContinuousClock.swift

@@ -21,7 +21,7 @@ import Swift
 ///
 /// This clock is suitable for high resolution measurements of execution.
 @available(SwiftStdlib 5.7, *)
-public struct ContinuousClock {
+public struct ContinuousClock: Sendable {
   /// A continuous point in time used for `ContinuousClock`.
   public struct Instant: Codable, Sendable {
     internal var _value: Swift.Duration

stdlib/public/Concurrency/SuspendingClock.swift

@@ -21,7 +21,7 @@ import Swift
 ///
 /// This clock is suitable for high resolution measurements of execution.
 @available(SwiftStdlib 5.7, *)
-public struct SuspendingClock {
+public struct SuspendingClock: Sendable {
   public struct Instant: Codable, Sendable {
     internal var _value: Swift.Duration