Unify all of the task-creation builtins coming out of SILGen.

We've been building up this exponential explosion of task-creation
builtins because it's not currently possible to overload builtins.
As long as all of the operands are scalar, though, it's pretty easy
to peephole optional injections in IRGen, which means we can at
least just use a single builtin in SIL and then break it apart in
IRGen to decide which options to set.

I also eliminated the metadata argument, which can easily be recreated
from the substitutions.  I also added proper verification for the builtin,
which required (1) getting `@Sendable` right more consistently and (2)
updating a bunch of tests checking for things that are not actually
valid, like passing a function that returns an Int directly.

Author: rjmccall

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift

@@ -44,11 +44,6 @@ extension BuiltinInst : OnoneSimplifyable {
            .AllocVector,
            .IsPOD:
         optimizeArgumentToThinMetatype(argument: 0, context)
-      case .CreateAsyncTask:
-        // In embedded Swift, CreateAsyncTask needs a thin metatype
-        if context.options.enableEmbeddedSwift {
-          optimizeArgumentToThinMetatype(argument: 1, context)
-        }
       case .ICMP_EQ:
         constantFoldIntegerEquality(isEqual: true, context)
       case .ICMP_NE:

include/swift/AST/ASTSynthesis.h

@@ -51,6 +51,7 @@ enum SingletonTypeSynthesizer {
   _rawUnsafeContinuation,
   _void,
   _word,
+  _swiftInt,       // Swift.Int
   _serialExecutor, // the '_Concurrency.SerialExecutor' protocol
   _taskExecutor,   // the '_Concurrency.TaskExecutor' protocol
   _actor,          // the '_Concurrency.Actor' protocol
@@ -70,6 +71,7 @@ inline Type synthesizeType(SynthesisContext &SC,
   case _void: return SC.Context.TheEmptyTupleType;
   case _word: return BuiltinIntegerType::get(BuiltinIntegerWidth::pointer(),
                                              SC.Context);
+  case _swiftInt: return SC.Context.getIntType();
   case _serialExecutor:
     return SC.Context.getProtocol(KnownProtocolKind::SerialExecutor)
       ->getDeclaredInterfaceType();
@@ -88,6 +90,11 @@ inline Type synthesizeType(SynthesisContext &SC,
   }
 }
 
+enum RepresentationSynthesizer {
+  _thin,
+  _thick
+};
+
 /// A synthesizer which generates an integer type.
 struct IntegerTypeSynthesizer {
   unsigned BitWidth;
@@ -131,6 +138,23 @@ Type synthesizeType(SynthesisContext &SC,
   return MetatypeType::get(synthesizeType(SC, M.Sub));
 }
 
+template <class S>
+struct RepMetatypeTypeSynthesizer {
+  S Sub;
+  RepresentationSynthesizer Rep;
+};
+template <class S>
+constexpr RepMetatypeTypeSynthesizer<S>
+_metatype(S sub, RepresentationSynthesizer rep ) {
+  return {sub, rep};
+}
+template <class S>
+Type synthesizeType(SynthesisContext &SC,
+                    const RepMetatypeTypeSynthesizer<S> &M) {
+  auto instanceType = synthesizeType(SC, M.Sub);
+  return MetatypeType::get(instanceType, synthesizeMetatypeRepresentation(M.Rep));
+}
+
 /// A synthesizer which generates an existential type from a requirement type.
 template <class S>
 struct ExistentialTypeSynthesizer {
@@ -146,6 +170,16 @@ Type synthesizeType(SynthesisContext &SC,
   return ExistentialType::get(synthesizeType(SC, M.Sub));
 }
 
+MetatypeRepresentation
+synthesizeMetatypeRepresentation(RepresentationSynthesizer rep) {
+  switch (rep) {
+  case _thin: return MetatypeRepresentation::Thin;
+  case _thick: return MetatypeRepresentation::Thick;
+  // TOOD: maybe add _objc?
+  }
+  llvm_unreachable("bad kind");
+}
+
 /// A synthesizer which generates an existential metatype type.
 template <class S>
 struct ExistentialMetatypeTypeSynthesizer {
@@ -160,6 +194,22 @@ Type synthesizeType(SynthesisContext &SC,
                     const ExistentialMetatypeTypeSynthesizer<S> &M) {
   return ExistentialMetatypeType::get(synthesizeType(SC, M.Sub));
 }
+template <class S>
+struct RepExistentialMetatypeTypeSynthesizer {
+  S Sub;
+  RepresentationSynthesizer Rep;
+};
+template <class S>
+constexpr RepExistentialMetatypeTypeSynthesizer<S>
+_existentialMetatype(S sub, RepresentationSynthesizer rep) {
+  return {sub, rep};
+}
+template <class S>
+Type synthesizeType(SynthesisContext &SC,
+                    const RepExistentialMetatypeTypeSynthesizer<S> &M) {
+  return ExistentialMetatypeType::get(synthesizeType(SC, M.Sub),
+                                      synthesizeMetatypeRepresentation(M.Rep));
+}
 
 /// A synthesizer that generates a MoveOnly wrapper of a type.
 template <class S>
@@ -341,22 +391,21 @@ void synthesizeParameterTypes(SynthesisContext &SC,
 }
 
 /// Synthesize function ExtInfo.
-enum FunctionRepresentationSynthesizer {
-  _thin,
-  _thick
-};
 template <class S> struct ThrowsSynthesizer { S sub; };
 template <class S> struct AsyncSynthesizer { S sub; };
 template <class S> struct NoescapeSynthesizer { S sub; };
+template <class S> struct SendableModSynthesizer { S sub; };
 template <class S>
 constexpr ThrowsSynthesizer<S> _throws(S sub) { return {sub}; }
 template <class S>
 constexpr AsyncSynthesizer<S> _async(S sub) { return {sub}; }
 template <class S>
 constexpr NoescapeSynthesizer<S> _noescape(S sub) { return {sub}; }
+template <class S>
+constexpr SendableModSynthesizer<S> _sendable(S sub) { return {sub}; }
 
 inline ASTExtInfo synthesizeExtInfo(SynthesisContext &SC,
-                                    FunctionRepresentationSynthesizer kind) {
+                                    RepresentationSynthesizer kind) {
   switch (kind) {
   case _thin: return ASTExtInfo().withRepresentation(
                                             FunctionTypeRepresentation::Thin);
@@ -379,6 +428,11 @@ ASTExtInfo synthesizeExtInfo(SynthesisContext &SC,
                              const NoescapeSynthesizer<S> &s) {
   return synthesizeExtInfo(SC, s.sub).withNoEscape();
 }
+template <class S>
+ASTExtInfo synthesizeExtInfo(SynthesisContext &SC,
+                             const SendableModSynthesizer<S> &s) {
+  return synthesizeExtInfo(SC, s.sub).withConcurrent();
+}
 
 /// Synthesize a function type.
 template <class ExtInfoS, class ResultS, class ParamsS>

include/swift/AST/Builtins.def

@@ -38,8 +38,6 @@ BUILTIN_CAST_OPERATION(PtrToInt, "ptrtoint", "n")
 BUILTIN_CAST_OPERATION(IntToPtr, "inttoptr", "n")
 BUILTIN_CAST_OPERATION(BitCast , "bitcast",  "n")
 
-#undef BUILTIN_CAST_OPERATION
-
 /// Cast-or-bitcast operations have type T1 -> T2.
 /// T1 and T2 may be the same size, unlike the corresponding true casts.
 #ifndef BUILTIN_CAST_OR_BITCAST_OPERATION
@@ -48,7 +46,6 @@ BUILTIN_CAST_OPERATION(BitCast , "bitcast",  "n")
 BUILTIN_CAST_OR_BITCAST_OPERATION(TruncOrBitCast, "truncOrBitCast", "n")
 BUILTIN_CAST_OR_BITCAST_OPERATION(ZExtOrBitCast,  "zextOrBitCast",  "n")
 BUILTIN_CAST_OR_BITCAST_OPERATION(SExtOrBitCast,  "sextOrBitCast",  "n")
-#undef BUILTIN_CAST_OR_BITCAST_OPERATION
 
 /// Binary operations have type (T,T) -> T.
 ///
@@ -139,11 +136,6 @@ BUILTIN_BINARY_OPERATION_ALL(URem,    urem,     "n", Integer)
 BUILTIN_BINARY_OPERATION_ALL(FRem,    frem,     "n", FloatOrVector)
 BUILTIN_BINARY_OPERATION_ALL(Xor,     xor,      "n", IntegerOrVector)
 BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC(Expect, "int_expect", "n", Integer)
-#undef BUILTIN_BINARY_OPERATION_ALL
-#undef BUILTIN_BINARY_OPERATION_POLYMORPHIC
-#undef BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC
-#undef BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR
-#undef BUILTIN_BINARY_OPERATION
 
 /// These builtins are analogous the similarly named llvm intrinsics. The
 /// difference between the two is that these are not expected to overflow,
@@ -165,7 +157,6 @@ BUILTIN_BINARY_OPERATION_WITH_OVERFLOW(SMulOver,
                                        "smul_with_overflow", Mul, "n", Integer)
 BUILTIN_BINARY_OPERATION_WITH_OVERFLOW(UMulOver,
                                        "umul_with_overflow", Mul, "n", Integer)
-#undef BUILTIN_BINARY_OPERATION_WITH_OVERFLOW
 
 /// Unary operations have type (T) -> T.
 #ifndef BUILTIN_UNARY_OPERATION
@@ -185,8 +176,6 @@ BUILTIN_UNARY_OPERATION(AssumeNonNegative, "assumeNonNegative", "n", Integer)
 // It only works on i1.
 BUILTIN_UNARY_OPERATION(AssumeTrue, "assume", "", Integer)
 
-#undef BUILTIN_UNARY_OPERATION
-
 // Binary predicates have type (T,T) -> i1 or (T, T) -> Vector<i1> for scalars
 // and vectors, respectively.
 #ifndef BUILTIN_BINARY_PREDICATE
@@ -217,7 +206,6 @@ BUILTIN_BINARY_PREDICATE(FCMP_ULT, "fcmp_ult", "n", FloatOrVector)
 BUILTIN_BINARY_PREDICATE(FCMP_ULE, "fcmp_ule", "n", FloatOrVector)
 BUILTIN_BINARY_PREDICATE(FCMP_UNE, "fcmp_une", "n", FloatOrVector)
 BUILTIN_BINARY_PREDICATE(FCMP_UNO, "fcmp_uno", "n", FloatOrVector)
-#undef BUILTIN_BINARY_PREDICATE
 
 // BUILTIN_SIL_OPERATION - Operations that can be lowered to SIL instructions.
 // These have various types.
@@ -549,8 +537,6 @@ BUILTIN_SIL_OPERATION(HopToActor, "hopToActor", None)
 /// Returns the number of items in a pack.
 BUILTIN_SIL_OPERATION(PackLength, "packLength", Special)
 
-#undef BUILTIN_SIL_OPERATION
-
 // BUILTIN_RUNTIME_CALL - A call into a runtime function.
 // These functions accept a single argument of any type.
 #ifndef BUILTIN_RUNTIME_CALL
@@ -569,8 +555,6 @@ BUILTIN_RUNTIME_CALL(ErrorInMain, "errorInMain", "")
 /// nominal type is Optional.
 BUILTIN_RUNTIME_CALL(IsOptionalType, "isOptional", "")
 
-#undef BUILTIN_RUNTIME_CALL
-
 // BUILTIN_MISC_OPERATION - Miscellaneous operations without a unifying class.
 // These have various types.
 #ifndef BUILTIN_MISC_OPERATION
@@ -976,7 +960,7 @@ BUILTIN_MISC_OPERATION(UnprotectedAddressOfBorrowOpaque, "unprotectedAddressOfBo
 /// Create a new asynchronous task, given flags, options, and a function to
 /// execute.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTask,
-    "createAsyncTask", "", Special)
+                                   "createAsyncTask", "", Special)
 
 /// createAsyncTaskInGroup(): (
 ///     Int,                            // flags
@@ -986,8 +970,8 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTask,
 ///
 /// Create a new asynchronous task future, given flags, a parent task,
 /// task group and a function to execute.
-BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskInGroup,
-    "createAsyncTaskInGroup", "", Special)
+BUILTIN_SIL_OPERATION(CreateAsyncTaskInGroup,
+                      "createAsyncTaskInGroup", Special)
 
 /// createAsyncDiscardingTaskInGroup(): (
 ///     Int,                               // flags
@@ -997,8 +981,8 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskInGroup,
 ///
 /// Create a new asynchronous discarding task, given flags, a parent task,
 /// task group and a function to execute.
-BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncDiscardingTaskInGroup,
-    "createAsyncDiscardingTaskInGroup", "", Special)
+BUILTIN_SIL_OPERATION(CreateAsyncDiscardingTaskInGroup,
+                      "createAsyncDiscardingTaskInGroup", Special)
 
 /// createAsyncTaskWithExecutor(): (
 ///     Int,                            // flags
@@ -1008,8 +992,8 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncDiscardingTaskInGroup,
 ///
 /// Create a new asynchronous task future, given flags, a parent task,
 /// task group and a function to execute.
-BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskWithExecutor,
-    "createAsyncTaskWithExecutor", "", Special)
+BUILTIN_SIL_OPERATION(CreateAsyncTaskWithExecutor,
+                      "createAsyncTaskWithExecutor", Special)
 
 /// createAsyncTaskInGroupWithExecutor(): (
 ///     Int,                            // flags
@@ -1020,8 +1004,8 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskWithExecutor,
 ///
 /// Create a new asynchronous task future, given flags, a parent task,
 /// task group and a function to execute.
-BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskInGroupWithExecutor,
-    "createAsyncTaskInGroupWithExecutor", "", Special)
+BUILTIN_SIL_OPERATION(CreateAsyncTaskInGroupWithExecutor,
+                      "createAsyncTaskInGroupWithExecutor", Special)
 
 /// createAsyncDiscardingTaskInGroupWithExecutor(): (
 ///     Int,                               // flags
@@ -1032,8 +1016,8 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTaskInGroupWithExecutor,
 ///
 /// Create a new asynchronous discarding task, given flags, a parent task,
 /// task group and a function to execute.
-BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncDiscardingTaskInGroupWithExecutor,
-    "createAsyncDiscardingTaskInGroupWithExecutor", "", Special)
+BUILTIN_SIL_OPERATION(CreateAsyncDiscardingTaskInGroupWithExecutor,
+                      "createAsyncDiscardingTaskInGroupWithExecutor", Special)
 
 /// Build a Builtin.Executor value from an "ordinary" task executor
 /// reference.
@@ -1102,10 +1086,6 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(InjectEnumTag, "injectEnumTag", "", Special)
 /// `any Actor` existential that refers to the local actor.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(DistributedActorAsAnyActor, "distributedActorAsAnyActor", "n", Special)
 
-#undef BUILTIN_MISC_OPERATION_WITH_SILGEN
-
-#undef BUILTIN_MISC_OPERATION
-
 /// Builtins for instrumentation added by sanitizers during SILGen.
 #ifndef BUILTIN_SANITIZER_OPERATION
 #define BUILTIN_SANITIZER_OPERATION(Id, Name, Attrs) BUILTIN(Id, Name, Attrs)
@@ -1115,8 +1095,6 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(DistributedActorAsAnyActor, "distributedActor
 /// TSanInoutAccess has type (T) -> ()
 BUILTIN_SANITIZER_OPERATION(TSanInoutAccess, "tsanInoutAccess", "")
 
-#undef BUILTIN_SANITIZER_OPERATION
-
 /// Builtins for compile-time type-checking operations used for unit testing.
 #ifndef BUILTIN_TYPE_CHECKER_OPERATION
 #define BUILTIN_TYPE_CHECKER_OPERATION(Id, Name) BUILTIN(Id, #Name, "n")
@@ -1127,8 +1105,6 @@ BUILTIN_TYPE_CHECKER_OPERATION(TypeJoinInout, type_join_inout)
 BUILTIN_TYPE_CHECKER_OPERATION(TypeJoinMeta, type_join_meta)
 BUILTIN_TYPE_CHECKER_OPERATION(TriggerFallbackDiagnostic, trigger_fallback_diagnostic)
 
-#undef BUILTIN_TYPE_CHECKER_OPERATION
-
 // BUILTIN_TYPE_TRAIT_OPERATION - Compile-time type trait operations.
 #ifndef BUILTIN_TYPE_TRAIT_OPERATION
 #define BUILTIN_TYPE_TRAIT_OPERATION(Id, Name) \
@@ -1142,5 +1118,20 @@ BUILTIN_TYPE_CHECKER_OPERATION(TriggerFallbackDiagnostic, trigger_fallback_diagn
 BUILTIN_TYPE_TRAIT_OPERATION(CanBeObjCClass, canBeClass)
 
 #undef BUILTIN_TYPE_TRAIT_OPERATION
-
+#undef BUILTIN_UNARY_OPERATION
+#undef BUILTIN_BINARY_PREDICATE
+#undef BUILTIN_RUNTIME_CALL
+#undef BUILTIN_MISC_OPERATION_WITH_SILGEN
+#undef BUILTIN_MISC_OPERATION
+#undef BUILTIN_SANITIZER_OPERATION
+#undef BUILTIN_TYPE_CHECKER_OPERATION
+#undef BUILTIN_BINARY_OPERATION_WITH_OVERFLOW
+#undef BUILTIN_BINARY_OPERATION_ALL
+#undef BUILTIN_BINARY_OPERATION_POLYMORPHIC
+#undef BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC
+#undef BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR
+#undef BUILTIN_BINARY_OPERATION
+#undef BUILTIN_CAST_OPERATION
+#undef BUILTIN_CAST_OR_BITCAST_OPERATION
+#undef BUILTIN_SIL_OPERATION
 #undef BUILTIN

include/swift/SIL/SILInstruction.h

@@ -4103,6 +4103,12 @@ class BuiltinInst final
   OperandValueArrayRef getArguments() const {
     return OperandValueArrayRef(getAllOperands());
   }
+  ArrayRef<Operand> getArgumentOperands() const {
+    return getAllOperands();
+  }
+  MutableArrayRef<Operand> getArgumentOperands() {
+    return getAllOperands();
+  }
 };
 
 /// Increments a given profiler counter for a given PGO function name. This is

include/swift/SIL/SILType.h

@@ -755,6 +755,11 @@ class SILType {
   /// otherwise, return the null type.
   SILType getOptionalObjectType() const;
 
+  /// Wraps this in one level of optional ype.
+  SILType wrapInOptionalType() const {
+    return SILType::getOptionalType(*this);
+  }
+
   /// Unwraps one level of optional type.
   /// Returns the lowered T if the given type is Optional<T>.
   /// Otherwise directly returns the given type.

lib/AST/Builtins.cpp

@@ -1522,7 +1522,8 @@ static ValueDecl *getCreateAsyncTask(ASTContext &ctx, Identifier id,
   if (withTaskExecutor) {
     builder.addParameter(makeConcrete(ctx.TheExecutorType)); // executor
   }
-  auto extInfo = ASTExtInfoBuilder().withAsync().withThrows().build();
+  auto extInfo = ASTExtInfoBuilder().withAsync().withThrows()
+                                    .withConcurrent(true).build();
   Type operationResultType;
   if (isDiscarding) {
     operationResultType = TupleType::getEmpty(ctx); // ()