Remove old runAsyncAndBlock internals

runAsyncAndBlock has long been dead, I'm pulling out the machinery that
lives in the runtime that used to support it. This is the first layer
that can go away.

Author: etcwilde

include/swift/Runtime/Concurrency.h

@@ -618,19 +618,6 @@ SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 NearestTaskDeadline
 swift_task_getNearestDeadline(AsyncTask *task);
 
-/// Run the given async function and block the current thread until
-/// it returns.  This is a hack added for testing purposes; eventually
-/// top-level code will be an async context, and the need for this in
-/// tests should go away.  We *definitely* do not want this to be part
-/// of the standard feature set.
-///
-/// The argument is a `() async -> ()` function, whose ABI is currently
-/// quite complex.  Eventually this should use a different convention;
-/// that's rdar://72105841.
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-void swift_task_runAndBlockThread(const void *function,
-                                  HeapObject *functionContext);
-
 /// Switch the current task to a new executor if we aren't already
 /// running on a compatible executor.
 ///

stdlib/public/Concurrency/Task.cpp

@@ -857,126 +857,6 @@ void swift_task_future_wait_throwingImpl(
   }
 }
 
-namespace {
-
-#if SWIFT_CONCURRENCY_COOPERATIVE_GLOBAL_EXECUTOR
-
-class RunAndBlockSemaphore {
-  bool Finished = false;
-public:
-  void wait() {
-    donateThreadToGlobalExecutorUntil([](void *context) {
-      return *reinterpret_cast<bool*>(context);
-    }, &Finished);
-
-    assert(Finished && "ran out of tasks before we were signalled");
-  }
-
-  void signal() {
-    Finished = true;
-  }
-};
-
-#else
-
-class RunAndBlockSemaphore {
-  ConditionVariable Queue;
-  ConditionVariable::Mutex Lock;
-  bool Finished = false;
-public:
-  /// Wait for a signal.
-  void wait() {
-    Lock.withLockOrWait(Queue, [&] {
-      return Finished;
-    });
-  }
-
-  void signal() {
-    Lock.withLockThenNotifyAll(Queue, [&]{
-      Finished = true;
-    });
-  }
-};
-
-#endif
-
-using RunAndBlockSignature =
-  AsyncSignature<void(HeapObject*), /*throws*/ false>;
-struct RunAndBlockContext: AsyncContext {
-  const void *Function;
-  HeapObject *FunctionContext;
-  RunAndBlockSemaphore *Semaphore;
-};
-using RunAndBlockCalleeContext =
-  AsyncCalleeContext<RunAndBlockContext, RunAndBlockSignature>;
-
-} // end anonymous namespace
-
-/// Second half of the runAndBlock async function.
-SWIFT_CC(swiftasync)
-static void runAndBlock_finish(SWIFT_ASYNC_CONTEXT AsyncContext *_context) {
-  auto calleeContext = static_cast<RunAndBlockCalleeContext*>(_context);
-
-  auto context = popAsyncContext(calleeContext);
-
-  context->Semaphore->signal();
-
-  return context->ResumeParent(context);
-}
-
-/// First half of the runAndBlock async function.
-SWIFT_CC(swiftasync)
-static void runAndBlock_start(SWIFT_ASYNC_CONTEXT AsyncContext *_context,
-                              SWIFT_CONTEXT HeapObject *closureContext) {
-  auto callerContext = static_cast<RunAndBlockContext*>(_context);
-
-  RunAndBlockSignature::FunctionType *function;
-  size_t calleeContextSize;
-  auto functionContext = callerContext->FunctionContext;
-  assert(closureContext == functionContext);
-  std::tie(function, calleeContextSize)
-    = getAsyncClosureEntryPointAndContextSize<
-      RunAndBlockSignature,
-      SpecialPointerAuthDiscriminators::AsyncRunAndBlockFunction
-    >(const_cast<void*>(callerContext->Function), functionContext);
-
-  auto calleeContext =
-    pushAsyncContext<RunAndBlockSignature>(callerContext,
-                                           calleeContextSize,
-                                           &runAndBlock_finish,
-                                           functionContext);
-  return reinterpret_cast<AsyncVoidClosureEntryPoint *>(function)(
-      calleeContext, functionContext);
-}
-
-// TODO: Remove this hack.
-void swift::swift_task_runAndBlockThread(const void *function,
-                                         HeapObject *functionContext) {
-  RunAndBlockSemaphore semaphore;
-
-  // Set up a task that runs the runAndBlock async function above.
-  auto flags = TaskCreateFlags();
-  flags.setPriority(JobPriority::Default);
-  auto pair = swift_task_create_common(
-      flags.getOpaqueValue(),
-      /*options=*/nullptr,
-      /*futureResultType=*/nullptr,
-      reinterpret_cast<ThinNullaryAsyncSignature::FunctionType *>(
-          &runAndBlock_start),
-      nullptr,
-      sizeof(RunAndBlockContext));
-  auto context = static_cast<RunAndBlockContext*>(pair.InitialContext);
-  context->Function = function;
-  context->FunctionContext = functionContext;
-  context->Semaphore = &semaphore;
-
-  // Enqueue the task.
-  swift_task_enqueueGlobal(pair.Task);
-
-  // Wait until the task completes.
-  semaphore.wait();
-}
-
 size_t swift::swift_task_getJobFlags(AsyncTask *task) {
   return task->Flags.getOpaqueValue();
 }