Merge pull request #80333 from tshortli/clock-measure-unsafe-inherit-executor

Author: tshortli

lib/Sema/TypeCheckConcurrency.cpp

@@ -2199,8 +2199,11 @@ void swift::introduceUnsafeInheritExecutorReplacements(
   if (lookup.empty())
     return;
 
-  auto baseNominal = base->getAnyNominal();
-  if (!baseNominal || !inConcurrencyModule(baseNominal))
+  SmallVector<NominalTypeDecl *, 4> nominalTypes;
+  namelookup::tryExtractDirectlyReferencedNominalTypes(base, nominalTypes);
+  if (llvm::none_of(nominalTypes, [](NominalTypeDecl *baseNominal) {
+        return inConcurrencyModule(baseNominal);
+      }))
     return;
 
   auto isReplaceable = [&](ValueDecl *decl) {

stdlib/public/Concurrency/Clock.swift

@@ -72,13 +72,22 @@ extension Clock {
     isolation: isolated (any Actor)? = #isolation,
     _ work: () async throws -> Void
   ) async rethrows -> Instant.Duration {
-    try await measure(work)
+    let start = now
+    try await work()
+    let end = now
+    return start.duration(to: end)
   }
 
+  // Note: hack to stage out @_unsafeInheritExecutor forms of various functions
+  // in favor of #isolation. The _unsafeInheritExecutor_ prefix is meaningful
+  // to the type checker.
+  //
+  // This function also doubles as an ABI-compatibility shim predating the
+  // introduction of #isolation.
   @available(SwiftStdlib 5.7, *)
+  @_silgen_name("$ss5ClockPsE7measurey8DurationQzyyYaKXEYaKF")
   @_unsafeInheritExecutor // for ABI compatibility
-  @usableFromInline
-  internal func measure(
+  public func _unsafeInheritExecutor_measure(
     _ work: () async throws -> Void
   ) async rethrows -> Instant.Duration {
     let start = now

test/Concurrency/unsafe_inherit_executor.swift

@@ -92,8 +92,10 @@ enum MyError: Error {
 case fail
 }
 
+protocol P {}
+
 @_unsafeInheritExecutor
-func unsafeCallerAvoidsNewLoop(clock: some Clock) async throws {
+func unsafeCallerAvoidsNewLoop() async throws {
   // expected-warning@-1{{@_unsafeInheritExecutor attribute is deprecated; consider an 'isolated' parameter defaulted to '#isolation' instead}}
 
   _ = await withUnsafeContinuation { (continuation: UnsafeContinuation<Int, Never>) in
@@ -129,13 +131,6 @@ func unsafeCallerAvoidsNewLoop(clock: some Clock) async throws {
   func operation() async throws -> Int { 7 }
   try await TL.$string.withValue("hello", operation: operation)
 
-  // FIXME: Clock.measure does not currently support this hack.
-  // expected-error@+1{{#isolation (introduced by a default argument) cannot be used within an '@_unsafeInheritExecutor' function}}
-  _ = try! await clock.measure {
-    print("so very slow")
-    try await Task.sleep(nanoseconds: 500)
-  }
-
   _ = await withDiscardingTaskGroup(returning: Int.self) { group in
     group.addTask {
       print("hello")
@@ -173,6 +168,32 @@ func unsafeCallerAvoidsNewLoop(clock: some Clock) async throws {
   }
 }
 
+@_unsafeInheritExecutor
+func unsafeClockCaller(
+  specificClock: ContinuousClock,
+  genericClock: some Clock,
+  existentialClock: any Clock,
+  existentialCompositionClock: any P & Clock,
+) async throws {
+  // expected-warning@-6{{@_unsafeInheritExecutor attribute is deprecated; consider an 'isolated' parameter defaulted to '#isolation' instead}}
+
+  _ = try! await specificClock.measure {
+    try await Task.sleep(nanoseconds: 500)
+  }
+
+  _ = try! await genericClock.measure {
+    try await Task.sleep(nanoseconds: 500)
+  }
+
+  _ = try! await existentialClock.measure {
+    try await Task.sleep(nanoseconds: 500)
+  }
+
+  _ = try! await existentialCompositionClock.measure {
+    try await Task.sleep(nanoseconds: 500)
+  }
+}
+
 @_unsafeInheritExecutor
 func _unsafeInheritExecutor_hacky() async { }
 // expected-warning@-1{{@_unsafeInheritExecutor attribute is deprecated; consider an 'isolated' parameter defaulted to '#isolation' instead}}