Sema: Extend _unsafeInheritExecutor_ hack to Clock.measure().

Fixes the bug in `swift::introduceUnsafeInheritExecutorReplacements()` that
prevented the hack from working with `Clock.measure()`. It isn't sufficient to
just check whether the nominal for the type base of a qualified lookup belongs
to the Concurrency module because that type may reference multiple types.
Instead, check all of the directly referenced types to match the behavior of
qualified lookup.

Resolves rdar://132581483.

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}}