Remove swift_task_create_async_let_future.

This is a small shim over `swift_task_create`. Use that instead.

Author: DougGregor

include/swift/Runtime/Concurrency.h

@@ -262,7 +262,7 @@ SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_asyncLet_start(AsyncLet *alet,
                           TaskOptionRecord *options,
                           const Metadata *futureResultType,
-                          void *closureEntryPoint, void *closureContext);
+                          void *closureEntryPoint, HeapObject *closureContext);
 
 /// This matches the ABI of a closure `<T>(Builtin.RawPointer) async -> T`
 using AsyncLetWaitSignature =

include/swift/Runtime/RuntimeFunctions.def

@@ -1660,7 +1660,7 @@ FUNCTION(DefaultActorDeallocateResilient,
 ///     TaskOptionRecord *options,
 ///     const Metadata *futureResultType,
 ///     void *closureEntryPoint,
-///     OpaqueValue *closureContext
+///     HeapObject *closureContext
 /// );
 FUNCTION(AsyncLetStart,
          swift_asyncLet_start, SwiftCC,

stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def

@@ -166,7 +166,7 @@ OVERRIDE_ASYNC_LET(asyncLet_start, void,
                     TaskOptionRecord *options,
                     const Metadata *futureResultType,
                     void *closureEntryPoint,
-                    void *closureContext
+                    HeapObject *closureContext
                    ),
                    (alet, options,
                     futureResultType, closureEntryPoint, closureContext))

stdlib/public/Concurrency/AsyncLet.cpp

@@ -93,15 +93,17 @@ SWIFT_CC(swift)
 static void swift_asyncLet_startImpl(AsyncLet *alet,
                                      TaskOptionRecord *options,
                                      const Metadata *futureResultType,
-                                     void *closureEntryPoint, void *closureContext) {
+                                     void *closureEntryPoint,
+                                     HeapObject *closureContext) {
   AsyncTask *parent = swift_task_getCurrent();
   assert(parent && "async-let cannot be created without parent task");
 
-  auto flags = JobFlags(JobKind::Task, parent->getPriority());
-  flags.task_setIsFuture(true);
-  flags.task_setIsChildTask(true);
+  auto flags = TaskCreateFlags();
+  flags.setPriority(parent->getPriority());
+  flags.setIsChildTask(true);
+  flags.setIsAsyncLetTask(true);
 
-  auto childTaskAndContext = swift_task_create_async_let_future(
+  auto childTaskAndContext = swift_task_create(
       flags.getOpaqueValue(),
       options,
       futureResultType,

stdlib/public/Concurrency/Task.cpp

@@ -677,38 +677,6 @@ swift::swift_task_create_f(
       function, /*closureContext=*/nullptr, initialContextSize);
 }
 
-/// Temporary hack to convert from job flags to task-creation flags,
-/// until we can eliminate the entry points that operate in terms of job
-/// flags.
-static size_t convertJobFlagsToTaskCreateFlags(size_t rawJobFlags) {
-  JobFlags jobFlags(rawJobFlags);
-  TaskCreateFlags taskCreateFlags;
-  taskCreateFlags.setPriority(jobFlags.getPriority());
-  taskCreateFlags.setIsChildTask(jobFlags.task_isChildTask());
-  taskCreateFlags.setIsAsyncLetTask(jobFlags.task_isAsyncLetTask());
-  return taskCreateFlags.getOpaqueValue();
-}
-
-AsyncTaskAndContext swift::swift_task_create_async_let_future(
-                     size_t rawFlags,
-                     TaskOptionRecord *options,
-                     const Metadata *futureResultType,
-                     void *closureEntry, void *closureContext) {
-  FutureAsyncSignature::FunctionType *taskEntry;
-  size_t initialContextSize;
-  std::tie(taskEntry, initialContextSize)
-    = getAsyncClosureEntryPointAndContextSize<
-      FutureAsyncSignature,
-      SpecialPointerAuthDiscriminators::AsyncFutureFunction
-    >(closureEntry, (HeapObject *)closureContext);
-
-  JobFlags flags(rawFlags);
-  flags.task_setIsAsyncLetTask(true);
-  return swift_task_create_common(
-      convertJobFlagsToTaskCreateFlags(flags.getOpaqueValue()), options,
-      futureResultType, taskEntry, closureContext, initialContextSize);
-}
-
 SWIFT_CC(swiftasync)
 static void swift_task_future_waitImpl(
   OpaqueValue *result,

stdlib/public/Concurrency/TaskPrivate.h

@@ -50,12 +50,6 @@ void runJobInEstablishedExecutorContext(Job *job);
 /// Clear the active task reference for the current thread.
 AsyncTask *_swift_task_clearCurrent();
 
-AsyncTaskAndContext swift_task_create_async_let_future(
-                     size_t flags,
-                     TaskOptionRecord *options,
-                     const Metadata *futureResultType,
-                     void *closureEntry, void *closureContext);
-
 #if defined(SWIFT_STDLIB_SINGLE_THREADED_RUNTIME)
 #define SWIFT_CONCURRENCY_COOPERATIVE_GLOBAL_EXECUTOR 1
 #else