Remove CreateAsyncTaskGroupFuture and swift_task_create_group_future.

We've moved everything over to `CreateAsyncTask` now.

Author: DougGregor

Diff for: include/swift/AST/Builtins.def

@@ -816,18 +816,6 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(EndAsyncLet, "endAsyncLet", "", Special)
 BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTask,
     "createAsyncTask", "", Special)
 
-/// createAsyncTaskGroupFuture(): (
-///     Int,                            // flags
-///     Builtin.RawPointer?,            // group
-///     Builtin.RawPointer?,            // options (TaskOptionRecord*)
-///     @escaping () async throws -> T  // function
-/// ) -> Builtin.NativeObject
-///
-/// Create a new asynchronous task future, given flags, a parent task,
-/// task group and a function to execute.
-BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskGroupFuture,
-    "createAsyncTaskGroupFuture", "", Special)
-
 /// globalStringTablePointer has type String -> Builtin.RawPointer.
 /// It returns an immortal, global string table pointer for strings constructed
 /// from string literals. We consider it effects as readnone meaning that it

Diff for: include/swift/Runtime/Concurrency.h

@@ -67,16 +67,6 @@ AsyncTaskAndContext swift_task_create_common(
     FutureAsyncSignature::FunctionType *function, void *closureContext,
     size_t initialContextSize);
 
-/// Create a task object with a future which will run the given
-/// closure, and offer its result to the task group
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-AsyncTaskAndContext swift_task_create_group_future(
-    size_t flags,
-    TaskGroup *group,
-    TaskOptionRecord *options,
-    const Metadata *futureResultType,
-    void *closureEntryPoint, HeapObject * /* +1 */ closureContext);
-
 /// Allocate memory in a task.
 ///
 /// This must be called synchronously with the task.

Diff for: include/swift/Runtime/RuntimeFunctions.def

@@ -1547,24 +1547,6 @@ FUNCTION(TaskCancel,
          ARGS(SwiftTaskPtrTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
-// AsyncTaskAndContext swift_task_create_group_future(
-//     size_t flags,
-//     TaskGroup *group,
-//     TaskOptionRecord *options
-//     const Metadata *futureResultType,
-//     void *closureEntry, HeapObject *closureContext);
-FUNCTION(TaskCreateGroupFuture,
-         swift_task_create_group_future, SwiftCC,
-         ConcurrencyAvailability,
-         RETURNS(AsyncTaskAndContextTy),
-         ARGS(SizeTy,
-              SwiftTaskGroupPtrTy,
-              SwiftTaskOptionRecordPtrTy,
-              TypeMetadataPtrTy,
-              Int8PtrTy,
-              RefCountedPtrTy),
-         ATTRS(NoUnwind, ArgMemOnly))
-
 // AsyncTaskAndContext swift_task_create(
 //     size_t taskCreateFlags,
 //     TaskOptionRecord *options,

Diff for: lib/AST/Builtins.cpp

@@ -1437,22 +1437,6 @@ static ValueDecl *getCreateAsyncTask(ASTContext &ctx, Identifier id) {
   return builder.build(id);
 }
 
-static ValueDecl *getCreateAsyncTaskGroupFuture(ASTContext &ctx, Identifier id) {
-  BuiltinFunctionBuilder builder(ctx);
-  auto genericParam = makeGenericParam().build(builder); // <T>
-  builder.addParameter(makeConcrete(ctx.getIntType())); // 0 flags
-  builder.addParameter(
-      makeConcrete(OptionalType::get(ctx.TheRawPointerType))); // 1 group
-  builder.addParameter(
-      makeConcrete(OptionalType::get(ctx.TheRawPointerType))); // 2 options
-  auto extInfo = ASTExtInfoBuilder().withAsync().withThrows().build();
-  builder.addParameter(
-      makeConcrete(FunctionType::get({ }, genericParam, extInfo))); // 3 operation
-  builder.setResult(makeConcrete(getAsyncTaskAndContextType(ctx)));
-
-  return builder.build(id);
-}
-
 static ValueDecl *getConvertTaskToJob(ASTContext &ctx, Identifier id) {
   return getBuiltinFunction(ctx, id,
                             _thin,
@@ -2764,9 +2748,6 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::CreateAsyncTask:
     return getCreateAsyncTask(Context, Id);
 
-  case BuiltinValueKind::CreateAsyncTaskGroupFuture:
-    return getCreateAsyncTaskGroupFuture(Context, Id);
-
   case BuiltinValueKind::ConvertTaskToJob:
     return getConvertTaskToJob(Context, Id);
 

Diff for: lib/IRGen/GenBuiltin.cpp

@@ -270,14 +270,8 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
-  if (Builtin.ID == BuiltinValueKind::CreateAsyncTask ||
-      Builtin.ID == BuiltinValueKind::CreateAsyncTaskGroupFuture) {
-
+  if (Builtin.ID == BuiltinValueKind::CreateAsyncTask) {
     auto flags = args.claimNext();
-    auto taskGroup =
-        (Builtin.ID == BuiltinValueKind::CreateAsyncTaskGroupFuture)
-        ? args.claimNext()
-        : nullptr;
     auto taskOptions = args.claimNext();
     auto futureResultType = args.claimNext();
     auto taskFunction = args.claimNext();
@@ -286,7 +280,6 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     auto newTaskAndContext = emitTaskCreate(
         IGF,
         flags,
-        taskGroup,
         taskOptions,
         futureResultType,
         taskFunction, taskContext,

Diff for: lib/IRGen/GenCall.cpp

@@ -3860,7 +3860,6 @@ void irgen::emitTaskCancel(IRGenFunction &IGF, llvm::Value *task) {
 llvm::Value *irgen::emitTaskCreate(
     IRGenFunction &IGF,
     llvm::Value *flags,
-    llvm::Value *taskGroup,
     llvm::Value *taskOptions,
     llvm::Value *futureResultType,
     llvm::Value *taskFunction,
@@ -3869,26 +3868,13 @@ llvm::Value *irgen::emitTaskCreate(
   llvm::CallInst *result;
   taskOptions = IGF.Builder.CreateBitOrPointerCast(
       taskOptions, IGF.IGM.SwiftTaskOptionRecordPtrTy);
-  if (taskGroup && futureResultType) {
-    taskGroup = IGF.Builder.CreateBitOrPointerCast(
-        taskGroup, IGF.IGM.SwiftTaskGroupPtrTy);
-    result = IGF.Builder.CreateCall(
-        IGF.IGM.getTaskCreateGroupFutureFn(),
-        {flags,
-         taskGroup,
-         taskOptions,
-         futureResultType,
-         taskFunction, localContextInfo});
-  } else if (futureResultType) {
-    result = IGF.Builder.CreateCall(
-      IGF.IGM.getTaskCreateFn(),
-      {flags,
-       taskOptions,
-       futureResultType,
-       taskFunction, localContextInfo});
-  } else {
-    llvm_unreachable("no future?!");
-  }
+  assert(futureResultType && "No future?!");
+  result = IGF.Builder.CreateCall(
+    IGF.IGM.getTaskCreateFn(),
+    {flags,
+     taskOptions,
+     futureResultType,
+     taskFunction, localContextInfo});
   result->setDoesNotThrow();
   result->setCallingConv(IGF.IGM.SwiftCC);
 

Diff for: lib/IRGen/GenCall.h

@@ -229,7 +229,6 @@ namespace irgen {
   llvm::Value *emitTaskCreate(
     IRGenFunction &IGF,
     llvm::Value *flags,
-    llvm::Value *taskGroup,
     llvm::Value *taskOptions,
     llvm::Value *futureResultType,
     llvm::Value *taskFunction,

Diff for: lib/SIL/IR/OperandOwnership.cpp

@@ -766,7 +766,6 @@ BUILTIN_OPERAND_OWNERSHIP(ForwardingConsume, COWBufferForReading)
 BUILTIN_OPERAND_OWNERSHIP(ForwardingConsume, UnsafeGuaranteed)
 
 const int PARAMETER_INDEX_CREATE_ASYNC_TASK_FUTURE_FUNCTION = 3;
-const int PARAMETER_INDEX_CREATE_ASYNC_TASK_GROUP_FUTURE_FUNCTION = 4;
 
 OperandOwnership
 OperandOwnershipBuiltinClassifier::visitCreateAsyncTask(BuiltinInst *bi,
@@ -782,20 +781,6 @@ OperandOwnershipBuiltinClassifier::visitCreateAsyncTask(BuiltinInst *bi,
   return OperandOwnership::InteriorPointer;
 }
 
-OperandOwnership
-OperandOwnershipBuiltinClassifier::visitCreateAsyncTaskGroupFuture(BuiltinInst *bi,
-                                                                   StringRef attr) {
-  // The function operand is consumed by the new task.
-  if (&op == &bi->getOperandRef(PARAMETER_INDEX_CREATE_ASYNC_TASK_GROUP_FUTURE_FUNCTION))
-    return OperandOwnership::DestroyingConsume;
-  
-  // FIXME: These are considered InteriorPointer because they may propagate a
-  // pointer into a borrowed values. If they do not propagate an interior pointer,
-  // then they should be InstantaneousUse instead and should not require a
-  // guaranteed value.
-  return OperandOwnership::InteriorPointer;
-}
-
 OperandOwnership OperandOwnershipBuiltinClassifier::
 visitResumeNonThrowingContinuationReturning(BuiltinInst *bi, StringRef attr) {
   // The value operand is consumed.

Diff for: lib/SIL/IR/ValueOwnership.cpp

@@ -533,7 +533,6 @@ CONSTANT_OWNERSHIP_BUILTIN(None, GlobalStringTablePointer)
 CONSTANT_OWNERSHIP_BUILTIN(None, GetCurrentAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(None, CancelAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTask)
-CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTaskGroupFuture)
 CONSTANT_OWNERSHIP_BUILTIN(None, ConvertTaskToJob)
 CONSTANT_OWNERSHIP_BUILTIN(None, InitializeDefaultActor)
 CONSTANT_OWNERSHIP_BUILTIN(None, DestroyDefaultActor)

Diff for: lib/SIL/Utils/MemAccessUtils.cpp

@@ -1855,7 +1855,6 @@ static void visitBuiltinAddress(BuiltinInst *builtin,
     case BuiltinValueKind::TSanInoutAccess:
     case BuiltinValueKind::CancelAsyncTask:
     case BuiltinValueKind::CreateAsyncTask:
-    case BuiltinValueKind::CreateAsyncTaskGroupFuture:
     case BuiltinValueKind::AutoDiffCreateLinearMapContext:
     case BuiltinValueKind::AutoDiffAllocateSubcontext:
     case BuiltinValueKind::InitializeDefaultActor:

Diff for: lib/SILGen/SILGenBuiltin.cpp

@@ -1458,42 +1458,6 @@ static ManagedValue emitBuiltinCreateAsyncTask(
   return SGF.emitManagedRValueWithCleanup(apply);
 }
 
-// Emit SIL for the named builtin: createAsyncTaskGroupFuture.
-static ManagedValue emitBuiltinCreateAsyncTaskGroupFuture(
-    SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
-    ArrayRef<ManagedValue> args, SGFContext C) {
-  ASTContext &ctx = SGF.getASTContext();
-  auto flags = args[0].forward(SGF);
-  auto group = args[1].borrow(SGF, loc).forward(SGF);
-  auto taskOptions = args[2].borrow(SGF, loc).forward(SGF);
-
-  // Form the metatype of the result type.
-  CanType futureResultType =
-      Type(
-        MetatypeType::get(GenericTypeParamType::get(0, 0, SGF.getASTContext()), MetatypeRepresentation::Thick))
-          .subst(subs)->getCanonicalType();
-  CanType anyTypeType = ExistentialMetatypeType::get(
-      ProtocolCompositionType::get(ctx, { }, false))->getCanonicalType();
-  auto &anyTypeTL = SGF.getTypeLowering(anyTypeType);
-  auto &futureResultTL = SGF.getTypeLowering(futureResultType);
-  auto futureResultMetadata = SGF.emitExistentialErasure(
-      loc, futureResultType, futureResultTL, anyTypeTL, { }, C,
-      [&](SGFContext C) -> ManagedValue {
-    return ManagedValue::forTrivialObjectRValue(
-      SGF.B.createMetatype(loc, SGF.getLoweredType(futureResultType)));
-  }).borrow(SGF, loc).forward(SGF);
-
-  auto function = emitFunctionArgumentForAsyncTaskEntryPoint(SGF, loc, args[3],
-                                                             futureResultType);
-  auto apply = SGF.B.createBuiltin(
-      loc,
-      ctx.getIdentifier(
-          getBuiltinName(BuiltinValueKind::CreateAsyncTaskGroupFuture)),
-      SGF.getLoweredType(getAsyncTaskAndContextType(ctx)), subs,
-      { flags, group, taskOptions, futureResultMetadata, function.forward(SGF) });
-  return SGF.emitManagedRValueWithCleanup(apply);
-}
-
 // Shared implementation of withUnsafeContinuation and
 // withUnsafe[Throwing]Continuation.
 static ManagedValue emitBuiltinWithUnsafeContinuation(

Diff for: lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -174,7 +174,6 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::CancelAsyncTask:
     case BuiltinValueKind::StartAsyncLet:
     case BuiltinValueKind::CreateAsyncTask:
-    case BuiltinValueKind::CreateAsyncTaskGroupFuture:
     case BuiltinValueKind::ConvertTaskToJob:
     case BuiltinValueKind::InitializeDefaultActor:
     case BuiltinValueKind::DestroyDefaultActor:

Diff for: stdlib/public/Concurrency/Task.cpp

@@ -716,34 +716,6 @@ AsyncTaskAndContext swift::swift_task_create_async_let_future(
       futureResultType, taskEntry, closureContext, initialContextSize);
 }
 
-AsyncTaskAndContext
-swift::swift_task_create_group_future(
-                        size_t flags,
-                        TaskGroup *group,
-                        TaskOptionRecord *options,
-                        const Metadata *futureResultType,
-                        void *closureEntry,
-                        HeapObject * /*+1*/closureContext) {
-  FutureAsyncSignature::FunctionType *taskEntry;
-  size_t initialContextSize;
-  std::tie(taskEntry, initialContextSize)
-    = getAsyncClosureEntryPointAndContextSize<
-      FutureAsyncSignature,
-      SpecialPointerAuthDiscriminators::AsyncFutureFunction
-    >(closureEntry, closureContext);
-
-  // Wire the group into the options.
-  TaskGroupTaskOptionRecord groupRecord(group);
-  if (group) {
-    groupRecord.Parent = options;
-    options = &groupRecord;
-  }
-
-  return swift_task_create_common(
-      convertJobFlagsToTaskCreateFlags(flags), options, futureResultType,
-      taskEntry, closureContext, initialContextSize);
-}
-
 SWIFT_CC(swiftasync)
 static void swift_task_future_waitImpl(
   OpaqueValue *result,

Diff for: test/SILGen/async_builtins.swift

@@ -24,14 +24,6 @@ public struct X {
     }
   }
 
-  // CHECK-LABEL: sil hidden [ossa] @$s4test1XV16launchGroupChildyyxlF : $@convention(method) <T> (@in_guaranteed T, X) -> () {
-  func launchGroupChild<T>(_ value: T) {
-    // CHECK: builtin "createAsyncTaskGroupFuture"<T>([[ZERO:%.*]] : $Int, [[NIL:%.*]] : $Optional<Builtin.RawPointer>, [[FN:%.*]] : $@async @callee_guaranteed @substituted <τ_0_0> () -> (@out τ_0_0, @error Error) for <T>) : $(Builtin.NativeObject, Builtin.RawPointer)
-    _ = Builtin.createAsyncTaskGroupFuture(0, nil, nil) { () async throws -> T in
-      return value
-    }
-  }
-
   public func launchRocker<T>(closure: @escaping () async throws -> T) {
     _ = Builtin.createAsyncTask(0, nil, closure)
   }