Merge pull request #72143 from rjmccall/builtin-create-task

Unify and simplify the task-creation builtins

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

@@ -16,6 +16,7 @@
 #include "swift/AST/Types.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
+#include "swift/AST/Expr.h"
 #include "swift/AST/GenericParamList.h"
 #include "swift/AST/ParameterList.h"
 
@@ -51,6 +52,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 +72,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 +91,11 @@ inline Type synthesizeType(SynthesisContext &SC,
   }
 }
 
+enum RepresentationSynthesizer {
+  _thin,
+  _thick
+};
+
 /// A synthesizer which generates an integer type.
 struct IntegerTypeSynthesizer {
   unsigned BitWidth;
@@ -131,6 +139,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 +171,16 @@ Type synthesizeType(SynthesisContext &SC,
   return ExistentialType::get(synthesizeType(SC, M.Sub));
 }
 
+MetatypeRepresentation
+inline 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 +195,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>
@@ -249,10 +300,12 @@ Type synthesizeType(SynthesisContext &SC,
 
 /// Synthesize parameter declarations.
 template <class S>
-ParamDecl *synthesizeParamDecl(SynthesisContext &SC, const S &s) {
+ParamDecl *synthesizeParamDecl(SynthesisContext &SC, const S &s,
+                               const char *label = nullptr) {
+  auto argLabelIdent = (label ? SC.Context.getIdentifier(label) : Identifier());
   auto type = synthesizeType(SC, s);
   auto PD = new (SC.Context) ParamDecl(SourceLoc(), SourceLoc(),
-                                       Identifier(), SourceLoc(),
+                                       argLabelIdent, SourceLoc(),
                                        Identifier(), SC.DC);
   PD->setSpecifier(ParamSpecifier::Default);
   PD->setInterfaceType(type);
@@ -280,8 +333,9 @@ constexpr SpecifiedParamSynthesizer<G> _inout(G sub) {
 }
 template <class S>
 ParamDecl *synthesizeParamDecl(SynthesisContext &SC,
-                               const SpecifiedParamSynthesizer<S> &s) {
-  auto param = synthesizeParamDecl(SC, s.sub);
+                               const SpecifiedParamSynthesizer<S> &s,
+                               const char *label = nullptr) {
+  auto param = synthesizeParamDecl(SC, s.sub, label);
   param->setSpecifier(s.specifier);
   return param;
 }
@@ -295,6 +349,61 @@ FunctionType::Param synthesizeParamType(SynthesisContext &SC,
   return param.withFlags(flags);
 }
 
+template <class S>
+void synthesizeDefaultArgument(SynthesisContext &SC, const S &s,
+                               ParamDecl *param) {
+  synthesizeDefaultArgumentFromExpr(SC, s, param);
+}
+template <class S>
+void synthesizeDefaultArgumentFromExpr(SynthesisContext &SC, const S &s,
+                                       ParamDecl *param) {
+  // FIXME: this works except that we tend to crash in diagnostics trying
+  // to render the default argument if you mess up the call.
+  auto expr = synthesizeExpr(SC, s);
+  param->setDefaultArgumentKind(DefaultArgumentKind::Normal);
+  param->setDefaultExpr(expr, /*type checked*/ false);
+}
+
+/// Default arguments.
+template <class S, class A>
+struct DefaultedSynthesizer { S sub; A arg; };
+template <class S, class A>
+constexpr DefaultedSynthesizer<S, A> _defaulted(S sub, A arg) {
+  return {sub, arg};
+}
+template <class S, class A>
+ParamDecl *synthesizeParamDecl(SynthesisContext &SC,
+                               const DefaultedSynthesizer<S, A> &s,
+                               const char *label = nullptr) {
+  auto param = synthesizeParamDecl(SC, s.sub, label);
+  synthesizeDefaultArgument(SC, s.arg, param);
+  return param;
+}
+template <class S, class A>
+FunctionType::Param synthesizeParamType(SynthesisContext &SC,
+                                        const DefaultedSynthesizer<S, A> &s) {
+  return synthesizeParamType(s.sub);
+}
+
+/// Labels.
+template <class S>
+struct LabelSynthesizer { const char *label; S sub; };
+template <class S>
+constexpr LabelSynthesizer<S> _label(const char *label, S sub) {
+  return {label, sub};
+}
+template <class S>
+ParamDecl *synthesizeParamDecl(SynthesisContext &SC,
+                               const LabelSynthesizer<S> &s) {
+  return synthesizeParamDecl(SC, s.sub, s.label);
+}
+template <class S>
+FunctionType::Param synthesizeParamType(SynthesisContext &SC,
+                                        const LabelSynthesizer<S> &s) {
+  auto label = SC.Context.getIdentifier(s.label);
+  return synthesizeParamType(SC, s.sub).withLabel(label);
+}
+
 /// Synthesize a parameter list.
 template <class... Params>
 struct ParameterListSynthesizer {
@@ -341,22 +450,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 +487,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>
@@ -414,6 +527,36 @@ Type synthesizeType(SynthesisContext &SC, const OptionalSynthesizer<S> &s) {
   return OptionalType::get(synthesizeType(SC, s.sub));
 }
 
+/// Expressions.
+enum SingletonExprSynthesizer {
+  _nil
+};
+inline Expr *synthesizeExpr(SynthesisContext &SC, SingletonExprSynthesizer s) {
+  switch (s) {
+  case _nil:
+    return new (SC.Context) NilLiteralExpr(SourceLoc(), /*implicit*/true);
+  }
+  llvm_unreachable("bad singleton kind");
+}
+inline void synthesizeDefaultArgument(SynthesisContext &SC,
+                                      SingletonExprSynthesizer s,
+                                      ParamDecl *param) {
+  switch (s) {
+  case _nil: {
+    auto expr = synthesizeExpr(SC, s);
+    param->setDefaultArgumentKind(DefaultArgumentKind::NilLiteral);
+    param->setDefaultExpr(expr, /*type checked*/ false);
+    return;
+  }
+
+  /*
+  default:
+    synthesizeDefaultArgumentFromExpr(SC, s, param);
+    return;
+   */
+  }
+}
+
 } // end namespace swift
 
 #endif