Merge pull request #72265 from eeckstein/fix-mandatory-inlining

eeckstein · web-flow · commit a24539171ca8 · 2024-03-13T18:52:43.000+01:00
MandatoryInlining and ConstExpr: look through sendable function conversions
diff --git a/include/swift/ABI/MetadataValues.h b/include/swift/ABI/MetadataValues.h
@@ -1119,7 +1119,7 @@ class TargetFunctionTypeFlags {
   }
 
   constexpr TargetFunctionTypeFlags<int_type>
-  withConcurrent(bool isSendable) const {
+  withSendable(bool isSendable) const {
     return TargetFunctionTypeFlags<int_type>(
         (Data & ~SendableMask) |
         (isSendable ? SendableMask : 0));
diff --git a/include/swift/AST/ASTSynthesis.h b/include/swift/AST/ASTSynthesis.h
@@ -490,7 +490,7 @@ ASTExtInfo synthesizeExtInfo(SynthesisContext &SC,
 template <class S>
 ASTExtInfo synthesizeExtInfo(SynthesisContext &SC,
                              const SendableModSynthesizer<S> &s) {
-  return synthesizeExtInfo(SC, s.sub).withConcurrent();
+  return synthesizeExtInfo(SC, s.sub).withSendable();
 }
 
 /// Synthesize a function type.
diff --git a/include/swift/AST/ExtInfo.h b/include/swift/AST/ExtInfo.h
@@ -620,7 +620,7 @@ class ASTExtInfoBuilder {
         clangTypeInfo, globalActor, thrownError, lifetimeDependenceInfo);
   }
   [[nodiscard]]
-  ASTExtInfoBuilder withConcurrent(bool concurrent = true) const {
+  ASTExtInfoBuilder withSendable(bool concurrent = true) const {
     return ASTExtInfoBuilder(
         concurrent ? (bits | SendableMask) : (bits & ~SendableMask),
         clangTypeInfo, globalActor, thrownError, lifetimeDependenceInfo);
@@ -808,10 +808,10 @@ class ASTExtInfo {
 
   /// Helper method for changing only the concurrent field.
   ///
-  /// Prefer using \c ASTExtInfoBuilder::withConcurrent for chaining.
+  /// Prefer using \c ASTExtInfoBuilder::withSendable for chaining.
   [[nodiscard]]
-  ASTExtInfo withConcurrent(bool concurrent = true) const {
-    return builder.withConcurrent(concurrent).build();
+  ASTExtInfo withSendable(bool isSendable = true) const {
+    return builder.withSendable(isSendable).build();
   }
 
   /// Helper method for changing only the throws field.
@@ -1122,7 +1122,7 @@ class SILExtInfoBuilder {
                              clangTypeInfo, lifetimeDependenceInfo);
   }
   [[nodiscard]]
-  SILExtInfoBuilder withConcurrent(bool isSendable = true) const {
+  SILExtInfoBuilder withSendable(bool isSendable = true) const {
     return SILExtInfoBuilder(isSendable ? (bits | SendableMask)
                                         : (bits & ~SendableMask),
                              clangTypeInfo, lifetimeDependenceInfo);
@@ -1294,8 +1294,8 @@ class SILExtInfo {
     return builder.withNoEscape(noEscape).build();
   }
   
-  SILExtInfo withConcurrent(bool isSendable = true) const {
-    return builder.withConcurrent(isSendable).build();
+  SILExtInfo withSendable(bool isSendable = true) const {
+    return builder.withSendable(isSendable).build();
   }
 
   SILExtInfo withAsync(bool isAsync = true) const {
diff --git a/include/swift/Demangling/TypeDecoder.h b/include/swift/Demangling/TypeDecoder.h
@@ -311,7 +311,7 @@ class ImplFunctionTypeFlags {
   }
 
   ImplFunctionTypeFlags
-  withConcurrent() const {
+  withSendable() const {
     return ImplFunctionTypeFlags(
         ImplFunctionRepresentation(Rep), Pseudogeneric, Escaping, true, Async,
         ErasedIsolation,
@@ -967,7 +967,7 @@ class TypeDecoder {
         ++firstChildIdx;
       }
 
-      flags = flags.withConcurrent(isSendable)
+      flags = flags.withSendable(isSendable)
           .withAsync(isAsync).withThrows(isThrow)
           .withDifferentiable(diffKind.isDifferentiable());
 
@@ -1046,7 +1046,7 @@ class TypeDecoder {
           if (!child->hasText())
             return MAKE_NODE_TYPE_ERROR0(child, "expected text");
           if (child->getText() == "@Sendable") {
-            flags = flags.withConcurrent();
+            flags = flags.withSendable();
           } else if (child->getText() == "@async") {
             flags = flags.withAsync();
           }
diff --git a/include/swift/RemoteInspection/TypeRefBuilder.h b/include/swift/RemoteInspection/TypeRefBuilder.h
@@ -1162,7 +1162,7 @@ class TypeRefBuilder {
       break;
     }
 
-    funcFlags = funcFlags.withConcurrent(flags.isSendable());
+    funcFlags = funcFlags.withSendable(flags.isSendable());
     funcFlags = funcFlags.withAsync(flags.isAsync());
     funcFlags = funcFlags.withDifferentiable(flags.isDifferentiable());
     extFuncFlags =
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -5740,6 +5740,9 @@ class ConvertFunctionInst final
   /// argument and return types, as well as all other attributes, after substitution,
   /// such as converting `$<A, B> in (A) -> B for <Int, String>` to `(Int) -> String`.
   bool onlyConvertsSubstitutions() const;
+
+  /// Returns true if the source and destination types only differ by `@Sendable`.
+  bool onlyConvertsSendable() const;
 };
 
 /// ConvertEscapeToNoEscapeInst - Change the type of a escaping function value
diff --git a/lib/AST/ASTDemangler.cpp b/lib/AST/ASTDemangler.cpp
@@ -475,7 +475,7 @@ Type ASTBuilder::createFunctionType(
                    resultDiffKind, clangFunctionType, isolation,
                    LifetimeDependenceInfo(), extFlags.hasTransferringResult())
                    .withAsync(flags.isAsync())
-                   .withConcurrent(flags.isSendable())
+                   .withSendable(flags.isSendable())
                    .build();
 
   return FunctionType::get(funcParams, output, einfo);
diff --git a/lib/AST/Builtins.cpp b/lib/AST/Builtins.cpp
@@ -1565,7 +1565,7 @@ static ValueDecl *getCreateAsyncTask(ASTContext &ctx, Identifier id,
     builder.addParameter(makeConcrete(ctx.TheExecutorType)); // executor
   }
   auto extInfo = ASTExtInfoBuilder().withAsync().withThrows()
-                                    .withConcurrent(true).build();
+                                    .withSendable(true).build();
   Type operationResultType;
   if (isDiscarding) {
     operationResultType = TupleType::getEmpty(ctx); // ()
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -3377,7 +3377,7 @@ mapSignatureExtInfo(AnyFunctionType::ExtInfo info,
     return AnyFunctionType::ExtInfo();
   return AnyFunctionType::ExtInfoBuilder()
       .withRepresentation(info.getRepresentation())
-      .withConcurrent(info.isSendable())
+      .withSendable(info.isSendable())
       .withAsync(info.isAsync())
       .withThrows(info.isThrowing(), info.getThrownError())
       .withClangFunctionType(info.getClangTypeInfo().getType())
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -920,7 +920,7 @@ Type TypeBase::stripConcurrency(bool recurse, bool dropGlobalActor) {
     // Strip off Sendable and (possibly) the global actor.
     ASTExtInfo extInfo =
         fnType->hasExtInfo() ? fnType->getExtInfo() : ASTExtInfo();
-    extInfo = extInfo.withConcurrent(false);
+    extInfo = extInfo.withSendable(false);
     if (dropGlobalActor)
       extInfo = extInfo.withoutIsolation();
 
@@ -3156,12 +3156,12 @@ static bool matchesFunctionType(CanAnyFunctionType fn1, CanAnyFunctionType fn2,
     // Removing '@Sendable' is ABI-compatible because there's nothing wrong with
     // a function being sendable when it doesn't need to be.
     if (!ext2.isSendable())
-      ext1 = ext1.withConcurrent(false);
+      ext1 = ext1.withSendable(false);
   }
 
   if (matchMode.contains(TypeMatchFlags::IgnoreFunctionSendability)) {
-    ext1 = ext1.withConcurrent(false);
-    ext2 = ext2.withConcurrent(false);
+    ext1 = ext1.withSendable(false);
+    ext2 = ext2.withSendable(false);
   }
 
   // If specified, allow an escaping function parameter to override a
diff --git a/lib/ClangImporter/ImportType.cpp b/lib/ClangImporter/ImportType.cpp
@@ -2005,7 +2005,7 @@ class GetSendableType :
 
   Result visitAnyFunctionType(AnyFunctionType *ty) {
     auto newFn = applyToFunctionType(ty, [](ASTExtInfo extInfo) {
-      return extInfo.withConcurrent();
+      return extInfo.withSendable();
     });
     return { newFn, true };
   }
diff --git a/lib/IRGen/MetadataRequest.cpp b/lib/IRGen/MetadataRequest.cpp
@@ -1428,7 +1428,7 @@ getFunctionTypeFlags(CanFunctionType type) {
   auto flags = FunctionTypeFlags()
       .withConvention(metadataConvention)
       .withAsync(type->isAsync())
-      .withConcurrent(type->isSendable())
+      .withSendable(type->isSendable())
       .withThrows(type->isThrowing())
       .withParameterFlags(hasParameterFlags)
       .withEscaping(isEscaping)
diff --git a/lib/SIL/IR/SILFunctionType.cpp b/lib/SIL/IR/SILFunctionType.cpp
@@ -2407,7 +2407,7 @@ static CanSILFunctionType getSILFunctionType(
   }
   auto silExtInfo = extInfoBuilder.withClangFunctionType(clangType)
                         .withIsPseudogeneric(pseudogeneric)
-                        .withConcurrent(isSendable)
+                        .withSendable(isSendable)
                         .withAsync(isAsync)
                         .withUnimplementable(unimplementable)
                         .withLifetimeDependenceInfo(
@@ -2493,7 +2493,7 @@ static CanSILFunctionType getSILFunctionTypeForInitAccessor(
   auto silExtInfo =
       SILExtInfoBuilder()
           .withRepresentation(SILFunctionTypeRepresentation::Thin)
-          .withConcurrent(substAccessorType->getExtInfo().isSendable())
+          .withSendable(substAccessorType->getExtInfo().isSendable())
           .build();
 
   return SILFunctionType::get(
diff --git a/lib/SIL/IR/SILInstructions.cpp b/lib/SIL/IR/SILInstructions.cpp
@@ -2744,6 +2744,16 @@ bool ConvertFunctionInst::onlyConvertsSubstitutions() const {
   return fromType->getUnsubstitutedType(M) == toType->getUnsubstitutedType(M);
 }
 
+static SILFunctionType *getNonSendableFuncType(SILType ty) {
+  auto fnTy = ty.castTo<SILFunctionType>();
+  return fnTy->getWithExtInfo(fnTy->getExtInfo().withSendable(false));
+}
+
+bool ConvertFunctionInst::onlyConvertsSendable() const {
+  return getNonSendableFuncType(getOperand()->getType()) ==
+         getNonSendableFuncType(getType());
+}
+
 ConvertEscapeToNoEscapeInst *ConvertEscapeToNoEscapeInst::create(
     SILDebugLocation DebugLoc, SILValue Operand, SILType Ty, SILFunction &F,
     bool isLifetimeGuaranteed) {
diff --git a/lib/SIL/IR/TypeLowering.cpp b/lib/SIL/IR/TypeLowering.cpp
@@ -3783,7 +3783,7 @@ getFunctionInterfaceTypeWithCaptures(TypeConverter &TC,
       AnyFunctionType::ExtInfoBuilder(FunctionType::Representation::Thin,
                                       funcType->isThrowing(),
                                       funcType->getThrownError())
-          .withConcurrent(funcType->isSendable())
+          .withSendable(funcType->isSendable())
           .withAsync(funcType->isAsync())
           .withIsolation(funcType->getIsolation())
           .withLifetimeDependenceInfo(funcType->getLifetimeDependenceInfo())
diff --git a/lib/SIL/Verifier/SILVerifier.cpp b/lib/SIL/Verifier/SILVerifier.cpp
@@ -2305,7 +2305,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       auto fnType = requireObjectType(SILFunctionType, arguments[4],
                                       "result of createAsyncTask");
       auto expectedExtInfo =
-        SILExtInfoBuilder().withAsync(true).withConcurrent(true).build();
+        SILExtInfoBuilder().withAsync(true).withSendable(true).build();
       require(fnType->getExtInfo().isEqualTo(expectedExtInfo, /*clang types*/true),
               "function argument to createAsyncTask has incorrect ext info");
       // FIXME: it'd be better if we took a consuming closure here
diff --git a/lib/SILGen/SILGenBridging.cpp b/lib/SILGen/SILGenBridging.cpp
@@ -1511,7 +1511,7 @@ SILFunction *SILGenFunction::emitNativeAsyncToForeignThunk(SILDeclRef thunk) {
   auto closureExtInfo = objcFnTy->getExtInfo().intoBuilder()
     .withRepresentation(SILFunctionTypeRepresentation::Thin)
     .withAsync()
-    .withConcurrent()
+    .withSendable()
     .build();
   auto closureTy = objcFnTy->getWithExtInfo(closureExtInfo);
   
diff --git a/lib/SILGen/SILGenBuiltin.cpp b/lib/SILGen/SILGenBuiltin.cpp
@@ -1620,7 +1620,7 @@ static ManagedValue emitCreateAsyncTask(SILGenFunction &SGF, SILLocation loc,
         ASTExtInfoBuilder()
             .withAsync()
             .withThrows()
-            .withConcurrent(true)
+            .withSendable(true)
             .withRepresentation(GenericFunctionType::Representation::Swift)
             .build();
 
@@ -1733,7 +1733,7 @@ SILGenFunction::emitCreateAsyncMainTask(SILLocation loc, SubstitutionMap subs,
   CanType flagsType = ctx.getIntType()->getCanonicalType();
   CanType functionType =
     FunctionType::get({}, ctx.TheEmptyTupleType,
-                      ASTExtInfo().withAsync().withThrows().withConcurrent(true))
+                      ASTExtInfo().withAsync().withThrows().withSendable(true))
       ->getCanonicalType();
 
   using Param = FunctionType::Param;
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
@@ -2904,12 +2904,12 @@ static bool canEmitClosureFunctionUnderConversion(
   // interferes with the implementation of `reasync`.
   auto literalWithoutEffects = literalFnType->getExtInfo().intoBuilder()
     .withNoEscape(false)
-    .withConcurrent(false)
+    .withSendable(false)
     .withThrows(false, Type());
 
   auto convertedWithoutEffects = convertedFnType->getExtInfo().intoBuilder()
     .withNoEscape(false)
-    .withConcurrent(false)
+    .withSendable(false)
     .withThrows(false, Type());
 
   // If the converted type has erased isolation, remove the isolation from
diff --git a/lib/SILOptimizer/Mandatory/MandatoryInlining.cpp b/lib/SILOptimizer/Mandatory/MandatoryInlining.cpp
@@ -592,6 +592,20 @@ static SILValue getLoadedCalleeValue(LoadInst *li) {
   return si->getSrc();
 }
 
+static bool convertsThinEscapeToNoescape(ConvertFunctionInst *cv) {
+  // Example:
+  //   %1 = function_ref @thin_closure_impl : $() -> ()
+  //   %2 = convert_function %1 : $() -> () to $@noescape () -> ()
+  //
+  auto fromTy = cv->getOperand()->getType().castTo<SILFunctionType>();
+  if (fromTy->getExtInfo().hasContext())
+    return false;
+
+  auto toTy = cv->getType().castTo<SILFunctionType>();
+  auto escapeToTy = toTy->getWithExtInfo(toTy->getExtInfo().withNoEscape(false));
+  return fromTy == escapeToTy;
+}
+
 // PartialApply/ThinToThick -> ConvertFunction patterns are generated
 // by @noescape closures.
 //
@@ -602,32 +616,13 @@ static SILValue stripFunctionConversions(SILValue CalleeValue) {
   // Skip any copies that we see.
   CalleeValue = lookThroughOwnershipInsts(CalleeValue);
 
-  // We can also allow a thin @escape to noescape conversion as such:
-  // %1 = function_ref @thin_closure_impl : $@convention(thin) () -> ()
-  // %2 = convert_function %1 :
-  //      $@convention(thin) () -> () to $@convention(thin) @noescape () -> ()
-  // %3 = thin_to_thick_function %2 :
-  //  $@convention(thin) @noescape () -> () to
-  //            $@noescape @callee_guaranteed () -> ()
-  // %4 = apply %3() : $@noescape @callee_guaranteed () -> ()
   if (auto *ConvertFn = dyn_cast<ConvertFunctionInst>(CalleeValue)) {
-    // If the conversion only changes the substitution level of the function,
-    // we can also look through it.
-    if (ConvertFn->onlyConvertsSubstitutions())
+    if (ConvertFn->onlyConvertsSubstitutions() ||
+        ConvertFn->onlyConvertsSendable() ||
+        convertsThinEscapeToNoescape(ConvertFn)) {
       return stripFunctionConversions(ConvertFn->getOperand());
-
-    auto FromCalleeTy =
-        ConvertFn->getOperand()->getType().castTo<SILFunctionType>();
-    if (FromCalleeTy->getExtInfo().hasContext())
-      return CalleeValue;
-
-    auto ToCalleeTy = ConvertFn->getType().castTo<SILFunctionType>();
-    auto EscapingCalleeTy = ToCalleeTy->getWithExtInfo(
-        ToCalleeTy->getExtInfo().withNoEscape(false));
-    if (FromCalleeTy != EscapingCalleeTy)
-      return CalleeValue;
-
-    return lookThroughOwnershipInsts(ConvertFn->getOperand());
+    }
+    return CalleeValue;
   }
 
   // Ignore mark_dependence users. A partial_apply [stack] uses them to mark
diff --git a/lib/SILOptimizer/Utils/ConstExpr.cpp b/lib/SILOptimizer/Utils/ConstExpr.cpp
@@ -520,7 +520,7 @@ SymbolicValue ConstExprFunctionState::computeConstantValue(SILValue value) {
   // TODO: Certain covariant or otherwise ABI-compatible conversions should
   // be handled as well.
   if (auto cf = dyn_cast<ConvertFunctionInst>(value)) {
-    if (cf->onlyConvertsSubstitutions()) {
+    if (cf->onlyConvertsSubstitutions() || cf->onlyConvertsSendable()) {
       return getConstantValue(cf->getOperand());
     }
   }
diff --git a/lib/Sema/AssociatedTypeInference.cpp b/lib/Sema/AssociatedTypeInference.cpp
@@ -2122,7 +2122,7 @@ Type swift::adjustInferredAssociatedType(TypeAdjustment adjustment, Type type,
     if (adjustment == TypeAdjustment::NoescapeToEscaping)
       return info.withNoEscape(false);
     else
-      return info.withConcurrent(true);
+      return info.withSendable(true);
   };
 
   // If we have a noescape function type, make it escaping.
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -7349,7 +7349,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
     // to the closure without invalidating prior analysis.
     auto fromEI = fromFunc->getExtInfo();
     if (toEI.isSendable() && !fromEI.isSendable()) {
-      auto newFromFuncType = fromFunc->withExtInfo(fromEI.withConcurrent());
+      auto newFromFuncType = fromFunc->withExtInfo(fromEI.withSendable());
       if (applyTypeToClosureExpr(cs, expr, newFromFuncType)) {
         fromFunc = newFromFuncType->castTo<FunctionType>();
 
@@ -8949,7 +8949,7 @@ static Expr *wrapAsyncLetInitializer(
                   .has_value();
   auto extInfo = ASTExtInfoBuilder()
     .withAsync()
-    .withConcurrent()
+    .withSendable()
     .withThrows(throws, /*FIXME:*/Type())
     .build();
 
diff --git a/lib/Sema/CSBindings.cpp b/lib/Sema/CSBindings.cpp
@@ -671,7 +671,7 @@ bool BindingSet::finalize(
           bool isKeyPathSendable = capability && capability->second;
           if (!isKeyPathSendable && extInfo.isSendable()) {
             fnType = FunctionType::get(fnType->getParams(), fnType->getResult(),
-                                       extInfo.withConcurrent(false));
+                                       extInfo.withSendable(false));
           }
 
           updatedBindings.insert(binding.withType(fnType));
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -11879,7 +11879,7 @@ bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
   auto closureExtInfo = inferredClosureType->getExtInfo();
   if (auto contextualFnType = contextualType->getAs<FunctionType>()) {
     if (contextualFnType->isSendable())
-      closureExtInfo = closureExtInfo.withConcurrent();
+      closureExtInfo = closureExtInfo.withSendable();
   }
 
   // Isolated parameters override any other kind of isolation we might infer.
diff --git a/lib/Sema/ConstraintSystem.cpp b/lib/Sema/ConstraintSystem.cpp
diff --git a/lib/Sema/TypeCheckConcurrency.cpp b/lib/Sema/TypeCheckConcurrency.cpp
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
diff --git a/test/SILOptimizer/constant_evaluable_profiler_test.swift b/test/SILOptimizer/constant_evaluable_profiler_test.swift
diff --git a/test/SILOptimizer/constant_evaluable_subset_test.swift b/test/SILOptimizer/constant_evaluable_subset_test.swift
diff --git a/test/SILOptimizer/diagnostic_constant_propagation.swift b/test/SILOptimizer/diagnostic_constant_propagation.swift
diff --git a/unittests/Reflection/TypeRef.cpp b/unittests/Reflection/TypeRef.cpp

Original file line number	Diff line number	Diff line change
`@@ -1119,7 +1119,7 @@ class TargetFunctionTypeFlags {`
`1119`	`1119`	`}`
`1120`	`1120`
`1121`	`1121`	`constexpr TargetFunctionTypeFlags<int_type>`
`1122`		`- withConcurrent(bool isSendable) const {`
	`1122`	`+ withSendable(bool isSendable) const {`
`1123`	`1123`	`return TargetFunctionTypeFlags<int_type>(`
`1124`	`1124`	`(Data & ~SendableMask) \|`
`1125`	`1125`	`(isSendable ? SendableMask : 0));`
Original file line number	Diff line number	Diff line change
`@@ -490,7 +490,7 @@ ASTExtInfo synthesizeExtInfo(SynthesisContext &SC,`
`490`	`490`	`template <class S>`
`491`	`491`	`ASTExtInfo synthesizeExtInfo(SynthesisContext &SC,`
`492`	`492`	`const SendableModSynthesizer<S> &s) {`
`493`		`- return synthesizeExtInfo(SC, s.sub).withConcurrent();`
	`493`	`+ return synthesizeExtInfo(SC, s.sub).withSendable();`
`494`	`494`	`}`
`495`	`495`
`496`	`496`	`/// Synthesize a function type.`
Original file line number	Diff line number	Diff line change
`@@ -1162,7 +1162,7 @@ class TypeRefBuilder {`
`1162`	`1162`	`break;`
`1163`	`1163`	`}`
`1164`	`1164`
`1165`		`- funcFlags = funcFlags.withConcurrent(flags.isSendable());`
	`1165`	`+ funcFlags = funcFlags.withSendable(flags.isSendable());`
`1166`	`1166`	`funcFlags = funcFlags.withAsync(flags.isAsync());`
`1167`	`1167`	`funcFlags = funcFlags.withDifferentiable(flags.isDifferentiable());`
`1168`	`1168`	`extFuncFlags =`
Original file line number	Diff line number	Diff line change
`@@ -1565,7 +1565,7 @@ static ValueDecl *getCreateAsyncTask(ASTContext &ctx, Identifier id,`
`1565`	`1565`	`builder.addParameter(makeConcrete(ctx.TheExecutorType)); // executor`
`1566`	`1566`	`}`
`1567`	`1567`	`auto extInfo = ASTExtInfoBuilder().withAsync().withThrows()`
`1568`		`- .withConcurrent(true).build();`
	`1568`	`+ .withSendable(true).build();`
`1569`	`1569`	`Type operationResultType;`
`1570`	`1570`	`if (isDiscarding) {`
`1571`	`1571`	`operationResultType = TupleType::getEmpty(ctx); // ()`