Ensure that we hop off the main actor after MainActor.run.

Asynchronous functions isolated to global actors hop to the global at
the beginning of the function but do not hop back on return. For
`MainActor.run`, this means that we would not "hop back" off the main
actor after executing the closure, which lead to too much code running
on the main thread. Dropping the "async" ensures that we hop back.
While we my also want the general "hop back" semantics for
asynchronous actor-isolated functions, for now this addresses the
problem with `MainActor.run`.

Fixes rdar://82138050.

Author: DougGregor

stdlib/public/Concurrency/MainActor.swift

@@ -45,14 +45,25 @@ import Swift
 @available(SwiftStdlib 5.5, *)
 extension MainActor {
   /// Execute the given body closure on the main actor.
-  public static func run<T>(
+  ///
+  /// Historical ABI entry point, superceded by the Sendable version that is
+  /// also inlined to back-deploy a semantic fix where this operation would
+  /// not hop back at the end.
+  @_silgen_name("$sScM3run10resultType4bodyxxm_xyYbKScMYcXEtYaKlFZ")
+  @usableFromInline
+  static func _historicalRunForABI<T>(
     resultType: T.Type = T.self,
     body: @MainActor @Sendable () throws -> T
   ) async rethrows -> T {
-    @MainActor func runOnMain(body: @MainActor @Sendable () throws -> T) async rethrows -> T {
-      return try body()
-    }
+    return try await body()
+  }
 
-    return try await runOnMain(body: body)
+  /// Execute the given body closure on the main actor.
+  @_alwaysEmitIntoClient
+  public static func run<T>(
+    resultType: T.Type = T.self,
+    body: @MainActor @Sendable () throws -> T
+  ) async rethrows -> T {
+    return try await body()
   }
 }