Skip to content

Commit 7cccbcc

Browse files
kateinoigakukunkateinoigakukun
authored
[DiscardingTG] Remove reabstraction thunk for () -> Void to () -> T (#70537)
Concurrency runtime expects discarding task operation entrypoint function not to have result type, but the current SILGen implementation generates reabstraction thunk to convert `() -> Void` to `() -> T` for the operation function. Since the `T` is always `Void` for DiscardingTG, the mismatch of result type expectation does not cause any problem on most platforms, but the signature mismatch causes a problem on WebAssembly. This patch introduces new builtin operations for creating discarding task, which always takes `() -> Void` as the operation function type.
1 parent 2404013 commit 7cccbcc

File tree

12 files changed

+199
-51
lines changed

12 files changed

+199
-51
lines changed

‎include/swift/AST/Builtins.def

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -986,6 +986,17 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTask,
986986
BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskInGroup,
987987
"createAsyncTaskInGroup", "", Special)
988988

989+
/// createAsyncDiscardingTaskInGroup(): (
990+
/// Int, // flags
991+
/// Builtin.RawPointer, // group
992+
/// @escaping () async throws -> Void // function
993+
/// ) -> Builtin.NativeObject
994+
///
995+
/// Create a new asynchronous discarding task, given flags, a parent task,
996+
/// task group and a function to execute.
997+
BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncDiscardingTaskInGroup,
998+
"createAsyncDiscardingTaskInGroup", "", Special)
999+
9891000
/// createAsyncTaskWithExecutor(): (
9901001
/// Int, // flags
9911002
/// Builtin.Executor, // executor
@@ -1009,6 +1020,18 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskWithExecutor,
10091020
BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskInGroupWithExecutor,
10101021
"createAsyncTaskInGroupWithExecutor", "", Special)
10111022

1023+
/// createAsyncDiscardingTaskInGroupWithExecutor(): (
1024+
/// Int, // flags
1025+
/// Builtin.RawPointer, // group
1026+
/// Builtin.Executor, // executor
1027+
/// @escaping () async throws -> Void // function
1028+
/// ) -> Builtin.NativeObject
1029+
///
1030+
/// Create a new asynchronous discarding task, given flags, a parent task,
1031+
/// task group and a function to execute.
1032+
BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncDiscardingTaskInGroupWithExecutor,
1033+
"createAsyncDiscardingTaskInGroupWithExecutor", "", Special)
1034+
10121035
/// Build a Builtin.Executor value from an "ordinary" task executor
10131036
/// reference.
10141037
BUILTIN_MISC_OPERATION_WITH_SILGEN(BuildOrdinaryTaskExecutorRef,

‎lib/AST/Builtins.cpp

Lines changed: 22 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1466,9 +1466,10 @@ Type swift::getAsyncTaskAndContextType(ASTContext &ctx) {
14661466
}
14671467

14681468
static ValueDecl *getCreateAsyncTask(ASTContext &ctx, Identifier id,
1469-
bool inGroup, bool withTaskExecutor) {
1470-
BuiltinFunctionBuilder builder(ctx);
1471-
auto genericParam = makeGenericParam().build(builder); // <T>
1469+
bool inGroup, bool withTaskExecutor,
1470+
bool isDiscarding) {
1471+
unsigned numGenericParams = isDiscarding ? 0 : 1;
1472+
BuiltinFunctionBuilder builder(ctx, numGenericParams);
14721473
builder.addParameter(makeConcrete(ctx.getIntType())); // 0 flags
14731474
if (inGroup) {
14741475
builder.addParameter(makeConcrete(ctx.TheRawPointerType)); // group
@@ -1477,8 +1478,14 @@ static ValueDecl *getCreateAsyncTask(ASTContext &ctx, Identifier id,
14771478
builder.addParameter(makeConcrete(ctx.TheExecutorType)); // executor
14781479
}
14791480
auto extInfo = ASTExtInfoBuilder().withAsync().withThrows().build();
1480-
builder.addParameter(
1481-
makeConcrete(FunctionType::get({}, genericParam, extInfo))); // operation
1481+
Type operationResultType;
1482+
if (isDiscarding) {
1483+
operationResultType = TupleType::getEmpty(ctx); // ()
1484+
} else {
1485+
operationResultType = makeGenericParam().build(builder); // <T>
1486+
}
1487+
builder.addParameter(makeConcrete(
1488+
FunctionType::get({}, operationResultType, extInfo))); // operation
14821489
builder.setResult(makeConcrete(getAsyncTaskAndContextType(ctx)));
14831490
return builder.build(id);
14841491
}
@@ -2928,16 +2935,22 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
29282935

29292936
case BuiltinValueKind::CreateAsyncTask:
29302937
return getCreateAsyncTask(Context, Id, /*inGroup=*/false,
2931-
/*withExecutor=*/false);
2938+
/*withExecutor=*/false, /*isDiscarding=*/false);
29322939
case BuiltinValueKind::CreateAsyncTaskInGroup:
29332940
return getCreateAsyncTask(Context, Id, /*inGroup=*/true,
2934-
/*withExecutor=*/false);
2941+
/*withExecutor=*/false, /*isDiscarding=*/false);
2942+
case BuiltinValueKind::CreateAsyncDiscardingTaskInGroup:
2943+
return getCreateAsyncTask(Context, Id, /*inGroup=*/true,
2944+
/*withExecutor=*/false, /*isDiscarding=*/true);
29352945
case BuiltinValueKind::CreateAsyncTaskWithExecutor:
29362946
return getCreateAsyncTask(Context, Id, /*inGroup=*/false,
2937-
/*withExecutor=*/true);
2947+
/*withExecutor=*/true, /*isDiscarding=*/false);
29382948
case BuiltinValueKind::CreateAsyncTaskInGroupWithExecutor:
29392949
return getCreateAsyncTask(Context, Id, /*inGroup=*/true,
2940-
/*withExecutor=*/true);
2950+
/*withExecutor=*/true, /*isDiscarding=*/false);
2951+
case BuiltinValueKind::CreateAsyncDiscardingTaskInGroupWithExecutor:
2952+
return getCreateAsyncTask(Context, Id, /*inGroup=*/true,
2953+
/*withExecutor=*/true, /*isDiscarding=*/true);
29412954

29422955
case BuiltinValueKind::TaskRunInline:
29432956
return getTaskRunInline(Context, Id);

‎lib/IRGen/GenBuiltin.cpp

Lines changed: 10 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -322,27 +322,34 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
322322

323323
if (Builtin.ID == BuiltinValueKind::CreateAsyncTask ||
324324
Builtin.ID == BuiltinValueKind::CreateAsyncTaskInGroup ||
325+
Builtin.ID == BuiltinValueKind::CreateAsyncDiscardingTaskInGroup ||
325326
Builtin.ID == BuiltinValueKind::CreateAsyncTaskWithExecutor ||
326-
Builtin.ID == BuiltinValueKind::CreateAsyncTaskInGroupWithExecutor) {
327+
Builtin.ID == BuiltinValueKind::CreateAsyncTaskInGroupWithExecutor ||
328+
Builtin.ID == BuiltinValueKind::CreateAsyncDiscardingTaskInGroupWithExecutor) {
327329

328330
auto flags = args.claimNext();
329331
auto taskGroup =
330332
(Builtin.ID == BuiltinValueKind::CreateAsyncTaskInGroup ||
331-
Builtin.ID == BuiltinValueKind::CreateAsyncTaskInGroupWithExecutor)
333+
Builtin.ID == BuiltinValueKind::CreateAsyncDiscardingTaskInGroup ||
334+
Builtin.ID == BuiltinValueKind::CreateAsyncTaskInGroupWithExecutor ||
335+
Builtin.ID == BuiltinValueKind::CreateAsyncDiscardingTaskInGroupWithExecutor)
332336
? args.claimNext()
333337
: nullptr;
334338

335339
// ExecutorRef is two pointers: {Identity, Implementation}
336340
std::pair<llvm::Value *, llvm::Value *> executorRef =
337341
(Builtin.ID == BuiltinValueKind::CreateAsyncTaskWithExecutor ||
338-
Builtin.ID == BuiltinValueKind::CreateAsyncTaskInGroupWithExecutor)
342+
Builtin.ID == BuiltinValueKind::CreateAsyncTaskInGroupWithExecutor ||
343+
Builtin.ID == BuiltinValueKind::CreateAsyncDiscardingTaskInGroupWithExecutor)
339344
? std::pair(args.claimNext(), args.claimNext())
340345
: std::pair(nullptr, nullptr);
341346

342347
// In embedded Swift, futureResultType is a thin metatype, not backed by any
343348
// actual value.
344349
llvm::Value *futureResultType =
345350
llvm::ConstantPointerNull::get(IGF.IGM.Int8PtrTy);
351+
// FIXME: We pass a metatype of result type even if it's statically known to
352+
// be discarded (`Void`) just to keep the existing behavior.
346353
if (!IGF.IGM.Context.LangOpts.hasFeature(Feature::Embedded)) {
347354
futureResultType = args.claimNext();
348355
}

‎lib/SIL/IR/OperandOwnership.cpp

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -912,8 +912,10 @@ ::visitStartAsyncLetWithLocalBuffer(BuiltinInst *bi, StringRef attr) {
912912

913913
const int PARAMETER_INDEX_CREATE_ASYNC_TASK_FUTURE_FUNCTION = 2;
914914
const int PARAMETER_INDEX_CREATE_ASYNC_TASK_GROUP_FUTURE_FUNCTION = 3;
915+
const int PARAMETER_INDEX_CREATE_ASYNC_DISCARDING_TASK_GROUP_FUTURE_FUNCTION = 3;
915916
const int PARAMETER_INDEX_CREATE_ASYNC_TASK_WITH_EXECUTOR_FUNCTION = 3;
916917
const int PARAMETER_INDEX_CREATE_ASYNC_TASK_GROUP_WITH_EXECUTOR_FUNCTION = 4;
918+
const int PARAMETER_INDEX_CREATE_ASYNC_DISCARDING_TASK_GROUP_WITH_EXECUTOR_FUNCTION = 4;
917919

918920
OperandOwnership OperandOwnershipBuiltinClassifier::visitCreateAsyncTask(
919921
BuiltinInst *bi, StringRef attr, int paramIndex) {
@@ -938,6 +940,14 @@ OperandOwnershipBuiltinClassifier::visitCreateAsyncTaskInGroup(BuiltinInst *bi,
938940
bi, attr, PARAMETER_INDEX_CREATE_ASYNC_TASK_GROUP_FUTURE_FUNCTION);
939941
}
940942

943+
OperandOwnership
944+
OperandOwnershipBuiltinClassifier::visitCreateAsyncDiscardingTaskInGroup(
945+
BuiltinInst *bi, StringRef attr) {
946+
return visitCreateAsyncTask(
947+
bi, attr,
948+
PARAMETER_INDEX_CREATE_ASYNC_DISCARDING_TASK_GROUP_FUTURE_FUNCTION);
949+
}
950+
941951
OperandOwnership
942952
OperandOwnershipBuiltinClassifier::visitCreateAsyncTaskWithExecutor(
943953
BuiltinInst *bi, StringRef attr) {
@@ -952,6 +962,13 @@ OperandOwnershipBuiltinClassifier::visitCreateAsyncTaskInGroupWithExecutor(
952962
bi, attr, PARAMETER_INDEX_CREATE_ASYNC_TASK_GROUP_WITH_EXECUTOR_FUNCTION);
953963
}
954964

965+
OperandOwnership
966+
OperandOwnershipBuiltinClassifier::visitCreateAsyncDiscardingTaskInGroupWithExecutor(
967+
BuiltinInst *bi, StringRef attr) {
968+
return visitCreateAsyncTask(
969+
bi, attr, PARAMETER_INDEX_CREATE_ASYNC_DISCARDING_TASK_GROUP_WITH_EXECUTOR_FUNCTION);
970+
}
971+
955972
OperandOwnership OperandOwnershipBuiltinClassifier::
956973
visitResumeNonThrowingContinuationReturning(BuiltinInst *bi, StringRef attr) {
957974
// The value operand is consumed.

‎lib/SIL/IR/ValueOwnership.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -590,8 +590,10 @@ CONSTANT_OWNERSHIP_BUILTIN(None, GetCurrentAsyncTask)
590590
CONSTANT_OWNERSHIP_BUILTIN(None, CancelAsyncTask)
591591
CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTask)
592592
CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTaskInGroup)
593+
CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncDiscardingTaskInGroup)
593594
CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTaskWithExecutor)
594595
CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTaskInGroupWithExecutor)
596+
CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncDiscardingTaskInGroupWithExecutor)
595597
CONSTANT_OWNERSHIP_BUILTIN(None, ConvertTaskToJob)
596598
CONSTANT_OWNERSHIP_BUILTIN(None, InitializeDefaultActor)
597599
CONSTANT_OWNERSHIP_BUILTIN(None, DestroyDefaultActor)

‎lib/SIL/Utils/MemAccessUtils.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2629,8 +2629,10 @@ static void visitBuiltinAddress(BuiltinInst *builtin,
26292629
case BuiltinValueKind::CancelAsyncTask:
26302630
case BuiltinValueKind::CreateAsyncTask:
26312631
case BuiltinValueKind::CreateAsyncTaskInGroup:
2632+
case BuiltinValueKind::CreateAsyncDiscardingTaskInGroup:
26322633
case BuiltinValueKind::CreateAsyncTaskWithExecutor:
26332634
case BuiltinValueKind::CreateAsyncTaskInGroupWithExecutor:
2635+
case BuiltinValueKind::CreateAsyncDiscardingTaskInGroupWithExecutor:
26342636
case BuiltinValueKind::AutoDiffCreateLinearMapContextWithType:
26352637
case BuiltinValueKind::AutoDiffAllocateSubcontextWithType:
26362638
case BuiltinValueKind::InitializeDefaultActor:

‎lib/SILGen/SILGenBuiltin.cpp

Lines changed: 64 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -1524,7 +1524,8 @@ ManagedValue emitBuiltinCreateAsyncTask(SILGenFunction &SGF, SILLocation loc,
15241524
SubstitutionMap subs,
15251525
ArrayRef<ManagedValue> args,
15261526
SGFContext C, BuiltinValueKind kind,
1527-
bool inGroup, bool withExecutor) {
1527+
bool inGroup, bool withExecutor,
1528+
bool isDiscarding) {
15281529
ASTContext &ctx = SGF.getASTContext();
15291530

15301531
SmallVector<SILValue, 4> builtinArgs;
@@ -1538,14 +1539,22 @@ ManagedValue emitBuiltinCreateAsyncTask(SILGenFunction &SGF, SILLocation loc,
15381539
builtinArgs.push_back(args[nextArgIdx++].forward(SGF)); // executor
15391540
}
15401541

1542+
CanType futureResultType;
15411543
// Form the metatype of the result type.
1542-
CanType futureResultType =
1543-
Type(MetatypeType::get(GenericTypeParamType::get(
1544-
/*isParameterPack*/ false,
1545-
/*depth*/ 0, /*index*/ 0, SGF.getASTContext()),
1546-
MetatypeRepresentation::Thick))
1547-
.subst(subs)
1548-
->getCanonicalType();
1544+
if (isDiscarding) {
1545+
futureResultType =
1546+
Type(MetatypeType::get(TupleType::getEmpty(ctx)->getCanonicalType(),
1547+
MetatypeRepresentation::Thick))
1548+
->getCanonicalType();
1549+
} else {
1550+
futureResultType = Type(MetatypeType::get(GenericTypeParamType::get(
1551+
/*isParameterPack*/ false,
1552+
/*depth*/ 0, /*index*/ 0,
1553+
SGF.getASTContext()),
1554+
MetatypeRepresentation::Thick))
1555+
.subst(subs)
1556+
->getCanonicalType();
1557+
}
15491558
CanType anyTypeType =
15501559
ExistentialMetatypeType::get(ctx.TheAnyType)->getCanonicalType();
15511560
auto &anyTypeTL = SGF.getTypeLowering(anyTypeType);
@@ -1569,21 +1578,27 @@ ManagedValue emitBuiltinCreateAsyncTask(SILGenFunction &SGF, SILLocation loc,
15691578
.withThrows()
15701579
.withRepresentation(GenericFunctionType::Representation::Swift)
15711580
.build();
1572-
auto genericSig = subs.getGenericSignature().getCanonicalSignature();
1573-
auto genericResult =
1574-
GenericTypeParamType::get(/*isParameterPack*/ false,
1575-
/*depth*/ 0, /*index*/ 0, SGF.getASTContext());
1576-
// <T> () async throws -> T
1577-
CanType functionTy =
1578-
GenericFunctionType::get(genericSig, {}, genericResult, extInfo)
1579-
->getCanonicalType();
1580-
AbstractionPattern origParam(genericSig, functionTy);
1581-
CanType substParamType = functionTy.subst(subs)->getCanonicalType();
1582-
auto reabstractedFun = SGF.emitSubstToOrigValue(loc, args[nextArgIdx],
1583-
origParam, substParamType);
1581+
1582+
ManagedValue entryPointFun;
1583+
if (isDiscarding) {
1584+
entryPointFun = args[nextArgIdx];
1585+
} else {
1586+
auto genericSig = subs.getGenericSignature().getCanonicalSignature();
1587+
auto genericResult = GenericTypeParamType::get(/*isParameterPack*/ false,
1588+
/*depth*/ 0, /*index*/ 0,
1589+
SGF.getASTContext());
1590+
// <T> () async throws -> T
1591+
CanType functionTy =
1592+
GenericFunctionType::get(genericSig, {}, genericResult, extInfo)
1593+
->getCanonicalType();
1594+
AbstractionPattern origParam(genericSig, functionTy);
1595+
CanType substParamType = functionTy.subst(subs)->getCanonicalType();
1596+
entryPointFun = SGF.emitSubstToOrigValue(loc, args[nextArgIdx], origParam,
1597+
substParamType);
1598+
}
15841599

15851600
auto function = emitFunctionArgumentForAsyncTaskEntryPoint(
1586-
SGF, loc, reabstractedFun, futureResultType);
1601+
SGF, loc, entryPointFun, futureResultType);
15871602
builtinArgs.push_back(function.forward(SGF));
15881603

15891604
auto apply = SGF.B.createBuiltin(
@@ -1596,9 +1611,19 @@ ManagedValue emitBuiltinCreateAsyncTask(SILGenFunction &SGF, SILLocation loc,
15961611
static ManagedValue emitBuiltinCreateAsyncTaskInGroup(
15971612
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
15981613
ArrayRef<ManagedValue> args, SGFContext C) {
1599-
return emitBuiltinCreateAsyncTask(SGF, loc, subs, args, C,
1600-
BuiltinValueKind::CreateAsyncTaskInGroup,
1601-
/*inGroup=*/true, /*withExecutor=*/false);
1614+
return emitBuiltinCreateAsyncTask(
1615+
SGF, loc, subs, args, C, BuiltinValueKind::CreateAsyncTaskInGroup,
1616+
/*inGroup=*/true, /*withExecutor=*/false, /*isDiscarding=*/false);
1617+
}
1618+
1619+
// Emit SIL for the named builtin: createAsyncDiscardingTaskInGroup.
1620+
static ManagedValue emitBuiltinCreateAsyncDiscardingTaskInGroup(
1621+
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
1622+
ArrayRef<ManagedValue> args, SGFContext C) {
1623+
return emitBuiltinCreateAsyncTask(
1624+
SGF, loc, subs, args, C,
1625+
BuiltinValueKind::CreateAsyncDiscardingTaskInGroup,
1626+
/*inGroup=*/true, /*withExecutor=*/false, /*isDiscarding=*/true);
16021627
}
16031628

16041629
// Emit SIL for the named builtin: createAsyncTaskWithExecutor.
@@ -1607,7 +1632,7 @@ static ManagedValue emitBuiltinCreateAsyncTaskWithExecutor(
16071632
ArrayRef<ManagedValue> args, SGFContext C) {
16081633
return emitBuiltinCreateAsyncTask(
16091634
SGF, loc, subs, args, C, BuiltinValueKind::CreateAsyncTaskWithExecutor,
1610-
/*inGroup=*/false, /*withExecutor=*/true);
1635+
/*inGroup=*/false, /*withExecutor=*/true, /*isDiscarding=*/false);
16111636
}
16121637
// Emit SIL for the named builtin: createAsyncTaskInGroupWithExecutor.
16131638
static ManagedValue emitBuiltinCreateAsyncTaskInGroupWithExecutor(
@@ -1616,17 +1641,27 @@ static ManagedValue emitBuiltinCreateAsyncTaskInGroupWithExecutor(
16161641
return emitBuiltinCreateAsyncTask(
16171642
SGF, loc, subs, args, C,
16181643
BuiltinValueKind::CreateAsyncTaskInGroupWithExecutor,
1619-
/*inGroup=*/true, /*withExecutor=*/true);
1644+
/*inGroup=*/true, /*withExecutor=*/true, /*isDiscarding=*/false);
1645+
}
1646+
1647+
// Emit SIL for the named builtin: createAsyncTaskInGroupWithExecutor.
1648+
static ManagedValue emitBuiltinCreateAsyncDiscardingTaskInGroupWithExecutor(
1649+
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
1650+
ArrayRef<ManagedValue> args, SGFContext C) {
1651+
return emitBuiltinCreateAsyncTask(
1652+
SGF, loc, subs, args, C,
1653+
BuiltinValueKind::CreateAsyncTaskInGroupWithExecutor,
1654+
/*inGroup=*/true, /*withExecutor=*/true, /*isDiscarding=*/true);
16201655
}
16211656

16221657
// Emit SIL for the named builtin: createAsyncTask.
16231658
ManagedValue emitBuiltinCreateAsyncTask(SILGenFunction &SGF, SILLocation loc,
16241659
SubstitutionMap subs,
16251660
ArrayRef<ManagedValue> args,
16261661
SGFContext C) {
1627-
return emitBuiltinCreateAsyncTask(SGF, loc, subs, args, C,
1628-
BuiltinValueKind::CreateAsyncTask,
1629-
/*inGroup=*/false, /*withExecutor=*/false);
1662+
return emitBuiltinCreateAsyncTask(
1663+
SGF, loc, subs, args, C, BuiltinValueKind::CreateAsyncTask,
1664+
/*inGroup=*/false, /*withExecutor=*/false, /*isDiscarding=*/false);
16301665
}
16311666

16321667
// Shared implementation of withUnsafeContinuation and

‎lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -187,8 +187,10 @@ static bool isBarrier(SILInstruction *inst) {
187187
case BuiltinValueKind::StartAsyncLet:
188188
case BuiltinValueKind::CreateAsyncTask:
189189
case BuiltinValueKind::CreateAsyncTaskInGroup:
190+
case BuiltinValueKind::CreateAsyncDiscardingTaskInGroup:
190191
case BuiltinValueKind::CreateAsyncTaskWithExecutor:
191192
case BuiltinValueKind::CreateAsyncTaskInGroupWithExecutor:
193+
case BuiltinValueKind::CreateAsyncDiscardingTaskInGroupWithExecutor:
192194
case BuiltinValueKind::TaskRunInline:
193195
case BuiltinValueKind::StartAsyncLetWithLocalBuffer:
194196
case BuiltinValueKind::ConvertTaskToJob:

0 commit comments

Comments
 (0)