Eliminate swift_task_create_f.

It's a tiny shim over `swift_task_create_common` that is rarely used.
Switch all of the former callers over the common API.

Author: DougGregor

include/swift/Runtime/Concurrency.h

@@ -44,15 +44,6 @@ AsyncTaskAndContext swift_task_create(
     const Metadata *futureResultType,
     void *closureEntry, HeapObject *closureContext);
 
-/// Create a task object that will run the given function.
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-AsyncTaskAndContext swift_task_create_f(
-    size_t flags,
-    TaskOptionRecord *options,
-    const Metadata *futureResultType,
-    ThinNullaryAsyncSignature::FunctionType *function,
-    size_t initialContextSize);
-
 /// Caution: not all future-initializing functions actually throw, so
 /// this signature may be incorrect.
 using FutureAsyncSignature =

stdlib/public/Concurrency/Task.cpp

@@ -665,18 +665,6 @@ AsyncTaskAndContext swift::swift_task_create(
       initialContextSize);
 }
 
-AsyncTaskAndContext
-swift::swift_task_create_f(
-    size_t flags,
-    TaskOptionRecord *options,
-    const Metadata *futureResultType,
-    ThinNullaryAsyncSignature::FunctionType *function,
-    size_t initialContextSize) {
-  return swift_task_create_common(
-      flags, options, futureResultType,
-      function, /*closureContext=*/nullptr, initialContextSize);
-}
-
 SWIFT_CC(swiftasync)
 static void swift_task_future_waitImpl(
   OpaqueValue *result,
@@ -850,12 +838,13 @@ void swift::swift_task_runAndBlockThread(const void *function,
   // Set up a task that runs the runAndBlock async function above.
   auto flags = TaskCreateFlags();
   flags.setPriority(JobPriority::Default);
-  auto pair = swift_task_create_f(
+  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;

unittests/runtime/Actor.cpp

@@ -142,11 +142,12 @@ createTaskWithContext(JobPriority priority, Fn &&fn) {
     TaskContinuationFromLambda<Fn, Context>::get(std::move(fn));
   TaskCreateFlags flags;
   flags.setPriority(priority);
-  auto pair = swift_task_create_f(flags.getOpaqueValue(),
-                                  nullptr,
-                                  nullptr,
-                                  invoke,
-                                  sizeof(Context));
+  auto pair = swift_task_create_common(flags.getOpaqueValue(),
+                                       nullptr,
+                                       nullptr,
+                                       invoke,
+                                       nullptr,
+                                       sizeof(Context));
   return std::make_pair(pair.Task,
                         static_cast<Context*>(pair.InitialContext));
 }

unittests/runtime/TaskStatus.cpp

@@ -56,12 +56,13 @@ static void withSimpleTask(TaskCreateFlags flags, T &&value,
                            undeduced<InvokeFunctionRef<T>> invokeFn,
                            BodyFunctionRef body) {
   auto taskAndContext =
-      swift_task_create_f(flags.getOpaqueValue(),
-                          nullptr,
-                          nullptr,
-                          reinterpret_cast<TaskContinuationFunction *>(
-                              &simpleTaskInvokeFunction<T>),
-                          sizeof(ValueContext<T>));
+      swift_task_create_common(flags.getOpaqueValue(),
+                               nullptr,
+                               nullptr,
+                               reinterpret_cast<TaskContinuationFunction *>(
+                                 &simpleTaskInvokeFunction<T>),
+                               nullptr,
+                               sizeof(ValueContext<T>));
 
   auto valueContext =
     static_cast<ValueContext<T>*>(taskAndContext.InitialContext);