Merge main 2021-03-18

.mailmap

@@ -1,7 +1,7 @@
 Adrian-Constantin Popescu <epsilon.gamma@gmail.com> <adrian-constantin.popescu@outlook.com>
 Alex Blewitt <alblue@apple.com> <alex.blewitt@gmail.com>
-Alex Hoppen <alex@alexhoppen.de> <alex@ateamer.de>
-Alex Hoppen <alex@alexhoppen.de> <ahoppen@apple.com>
+Alex Hoppen <ahoppen@apple.com> <alex@ateamer.de>
+Alex Hoppen <ahoppen@apple.com> <alex@alexhoppen.de>
 Alexis Beingessner <abeingessner@apple.com> <a.beingessner@gmail.com>
 Alper Çugun <github@alper.nl> <alper@users.noreply.github.com>
 Amr Aboelela <amraboelela@gmail.com> <amraboelela@users.noreply.github.com>

CMakeLists.txt

@@ -148,7 +148,7 @@ set(SWIFT_ANALYZE_CODE_COVERAGE FALSE CACHE STRING
 # SWIFT_VERSION is deliberately /not/ cached so that an existing build directory
 # can be reused when a new version of Swift comes out (assuming the user hasn't
 # manually set it as part of their own CMake configuration).
-set(SWIFT_VERSION "5.4")
+set(SWIFT_VERSION "5.5")
 
 set(SWIFT_VENDOR "" CACHE STRING
     "The vendor name of the Swift compiler")
@@ -196,13 +196,6 @@ if(SWIFT_PROFDATA_FILE AND EXISTS ${SWIFT_PROFDATA_FILE})
   add_definitions("-fprofile-instr-use=${SWIFT_PROFDATA_FILE}")
 endif()
 
-option(USE_SWIFT_ASYNC_LOWERING
-       "Indicates if Swiftc should use async-specific lowering for async
-        functions if it is supported for the target. The runtime also checks
-        this setting before using async-specific attributes. This only applies
-        to the async calling convention and not to the async context attribute."
-	TRUE)
-
 #
 # User-configurable Swift Standard Library specific options.
 #

docs/ABI/Mangling.rst

@@ -147,6 +147,9 @@ Globals
   // TODO check this::
   global ::= mangled-name 'TA'                     // partial application forwarder
   global ::= mangled-name 'Ta'                     // ObjC partial application forwarder
+  global ::= mangled-name 'Tw' index               // async partial apply thunk for a non-constant function
+  global ::= mangled-name 'TQ' index               // Async await continuation partial function
+  global ::= mangled-name 'TY' index               // Async suspend continuation partial function
 
   global ::= type 'w' VALUE-WITNESS-KIND // value witness
 
@@ -209,7 +212,7 @@ types where the metadata itself has unknown layout.)
   global ::= global 'TD'                 // dynamic dispatch thunk
   global ::= global 'Td'                 // direct method reference thunk
   global ::= global 'TI'                 // implementation of a dynamic_replaceable function
-  global :== global 'Tu'                 // async function pointer of a function
+  global ::= global 'Tu'                 // async function pointer of a function
   global ::= global 'TX'                 // function pointer of a dynamic_replaceable function
   global ::= entity entity 'TV'          // vtable override thunk, derived followed by base
   global ::= type label-list? 'D'        // type mangling for the debugger with label list for function types.

include/swift/ABI/Executor.h

@@ -114,11 +114,11 @@ class ExecutorRef {
 
 using JobInvokeFunction =
   SWIFT_CC(swiftasync)
-  void (Job *, ExecutorRef);
+  void (Job *);
 
 using TaskContinuationFunction =
   SWIFT_CC(swiftasync)
-  void (AsyncTask *, ExecutorRef, SWIFT_ASYNC_CONTEXT AsyncContext *);
+  void (SWIFT_ASYNC_CONTEXT AsyncContext *);
 
 template <class AsyncSignature>
 class AsyncFunctionPointer;

include/swift/ABI/Task.h

@@ -87,13 +87,13 @@ class alignas(2 * alignof(void*)) Job : public HeapObject {
   /// Given that we've fully established the job context in the current
   /// thread, actually start running this job.  To establish the context
   /// correctly, call swift_job_run or runJobInExecutorContext.
-  void runInFullyEstablishedContext(ExecutorRef currentExecutor);
+  void runInFullyEstablishedContext();
 
   /// Given that we've fully established the job context in the
   /// current thread, and that the job is a simple (non-task) job,
   /// actually start running this job.
-  void runSimpleInFullyEstablishedContext(ExecutorRef currentExecutor) {
-    RunJob(this, currentExecutor);
+  void runSimpleInFullyEstablishedContext() {
+    RunJob(this);
   }
 };
 
@@ -193,8 +193,8 @@ class AsyncTask : public Job {
   /// in the current thread, start running this task.  To establish
   /// the job context correctly, call swift_job_run or
   /// runInExecutorContext.
-  void runInFullyEstablishedContext(ExecutorRef currentExecutor) {
-    ResumeTask(this, currentExecutor, ResumeContext);
+  void runInFullyEstablishedContext() {
+    ResumeTask(ResumeContext);
   }
 
   /// Check whether this task has been cancelled.
@@ -390,7 +390,7 @@ class AsyncTask : public Job {
     }
 
     /// Retrieve the error.
-    SwiftError *&getError() { return *&error; }
+    SwiftError *&getError() { return error; }
 
     /// Compute the offset of the storage from the base of the future
     /// fragment.
@@ -433,7 +433,7 @@ class AsyncTask : public Job {
   ///
   /// Upon completion, any waiting tasks will be scheduled on the given
   /// executor.
-  void completeFuture(AsyncContext *context, ExecutorRef executor);
+  void completeFuture(AsyncContext *context);
 
   // ==== ----------------------------------------------------------------------
 
@@ -456,11 +456,11 @@ static_assert(sizeof(AsyncTask) == 14 * sizeof(void*),
 static_assert(alignof(AsyncTask) == 2 * alignof(void*),
               "AsyncTask alignment is wrong");
 
-inline void Job::runInFullyEstablishedContext(ExecutorRef currentExecutor) {
+inline void Job::runInFullyEstablishedContext() {
   if (auto task = dyn_cast<AsyncTask>(this))
-    task->runInFullyEstablishedContext(currentExecutor);
+    task->runInFullyEstablishedContext();
   else
-    runSimpleInFullyEstablishedContext(currentExecutor);
+    runSimpleInFullyEstablishedContext();
 }
 
 /// An asynchronous context within a task.  Generally contexts are
@@ -484,6 +484,7 @@ class alignas(MaximumAlignment) AsyncContext {
     ResumeParent;
 
   /// The executor that the parent needs to be resumed on.
+  /// FIXME: remove this
   ExecutorRef ResumeParentExecutor;
 
   /// Flags describing this context.
@@ -496,10 +497,9 @@ class alignas(MaximumAlignment) AsyncContext {
 
   AsyncContext(AsyncContextFlags flags,
                TaskContinuationFunction *resumeParent,
-               ExecutorRef resumeParentExecutor,
                AsyncContext *parent)
     : Parent(parent), ResumeParent(resumeParent),
-      ResumeParentExecutor(resumeParentExecutor),
+      ResumeParentExecutor(ExecutorRef::generic()),
       Flags(flags) {}
 
   AsyncContext(const AsyncContext &) = delete;
@@ -509,10 +509,10 @@ class alignas(MaximumAlignment) AsyncContext {
   ///
   /// Generally this should be tail-called.
   SWIFT_CC(swiftasync)
-  void resumeParent(AsyncTask *task, ExecutorRef executor) {
+  void resumeParent() {
     // TODO: destroy context before returning?
     // FIXME: force tail call
-    return ResumeParent(task, executor, Parent);
+    return ResumeParent(Parent);
   }
 };
 
@@ -529,11 +529,10 @@ class YieldingAsyncContext : public AsyncContext {
 
   YieldingAsyncContext(AsyncContextFlags flags,
                        TaskContinuationFunction *resumeParent,
-                       ExecutorRef resumeParentExecutor,
                        TaskContinuationFunction *yieldToParent,
                        ExecutorRef yieldToParentExecutor,
                        AsyncContext *parent)
-    : AsyncContext(flags, resumeParent, resumeParentExecutor, parent),
+    : AsyncContext(flags, resumeParent, parent),
       YieldToParent(yieldToParent),
       YieldToParentExecutor(yieldToParentExecutor) {}
 
@@ -550,19 +549,47 @@ class YieldingAsyncContext : public AsyncContext {
 /// futures.
 class FutureAsyncContext : public AsyncContext {
 public:
-  SwiftError **errorResult = nullptr;
-  OpaqueValue *indirectResult;
-
   using AsyncContext::AsyncContext;
 };
 
-/// An asynchronous context within a task that describes a general "Future"
-/// task that was started with a closure context.
-class FutureClosureAsyncContext : public FutureAsyncContext {
+/// This matches the ABI of a closure `() async throws -> ()`
+using AsyncVoidClosureEntryPoint =
+  SWIFT_CC(swiftasync)
+  void (SWIFT_ASYNC_CONTEXT AsyncContext *, SWIFT_CONTEXT HeapObject *);
+
+/// This matches the ABI of a closure `<T>() async throws -> T`
+using AsyncGenericClosureEntryPoint =
+    SWIFT_CC(swiftasync)
+    void(OpaqueValue *,
+         SWIFT_ASYNC_CONTEXT AsyncContext *, SWIFT_CONTEXT HeapObject *);
+
+/// This matches the ABI of the resume function of a closure
+///  `() async throws -> ()`.
+using AsyncVoidClosureResumeEntryPoint =
+  SWIFT_CC(swiftasync)
+  void(SWIFT_ASYNC_CONTEXT AsyncContext *, SWIFT_CONTEXT SwiftError *);
+
+class AsyncContextPrefix {
+public:
+  // Async closure entry point adhering to compiler calling conv (e.g directly
+  // passing the closure context instead of via the async context)
+  AsyncVoidClosureEntryPoint *__ptrauth_swift_task_resume_function
+      asyncEntryPoint;
+   HeapObject *closureContext;
+  SwiftError *errorResult;
+};
+
+/// Storage that is allocated before the AsyncContext to be used by an adapter
+/// of Swift's async convention and the ResumeTask interface.
+class FutureAsyncContextPrefix {
 public:
+  OpaqueValue *indirectResult;
+  // Async closure entry point adhering to compiler calling conv (e.g directly
+  // passing the closure context instead of via the async context)
+  AsyncGenericClosureEntryPoint *__ptrauth_swift_task_resume_function
+      asyncEntryPoint;
   HeapObject *closureContext;
-
-  using FutureAsyncContext::FutureAsyncContext;
+  SwiftError *errorResult;
 };
 
 } // end namespace swift

include/swift/ABI/TaskGroup.h

@@ -38,7 +38,7 @@ class alignas(Alignment_TaskGroup) TaskGroup {
   void *PrivateData[NumWords_TaskGroup];
 
   /// Upon a future task's completion, offer it to the task group it belongs to.
-  void offer(AsyncTask *completed, AsyncContext *context, ExecutorRef executor);
+  void offer(AsyncTask *completed, AsyncContext *context);
 };
 
 } // end namespace swift

include/swift/AST/ASTDemangler.h

@@ -59,6 +59,8 @@ class ASTBuilder {
   using BuiltType = swift::Type;
   using BuiltTypeDecl = swift::GenericTypeDecl *; // nominal or type alias
   using BuiltProtocolDecl = swift::ProtocolDecl *;
+  using BuiltSubstitution = std::pair<Type, Type>;
+  using BuiltRequirement = swift::Requirement;
   explicit ASTBuilder(ASTContext &ctx) : Ctx(ctx) {}
 
   ASTContext &getASTContext() { return Ctx; }
@@ -99,11 +101,14 @@ class ASTBuilder {
                           Type output, FunctionTypeFlags flags);
 
   Type createImplFunctionType(
-    Demangle::ImplParameterConvention calleeConvention,
-    ArrayRef<Demangle::ImplFunctionParam<Type>> params,
-    ArrayRef<Demangle::ImplFunctionResult<Type>> results,
-    Optional<Demangle::ImplFunctionResult<Type>> errorResult,
-    ImplFunctionTypeFlags flags);
+      Demangle::ImplParameterConvention calleeConvention,
+      BuiltRequirement *witnessMethodConformanceRequirement,
+      ArrayRef<BuiltType> GenericParameters,
+      ArrayRef<BuiltRequirement> Requirements,
+      ArrayRef<Demangle::ImplFunctionParam<Type>> params,
+      ArrayRef<Demangle::ImplFunctionResult<Type>> results,
+      Optional<Demangle::ImplFunctionResult<Type>> errorResult,
+      ImplFunctionTypeFlags flags);
 
   Type createProtocolCompositionType(ArrayRef<ProtocolDecl *> protocols,
                                      Type superclass,
@@ -128,8 +133,6 @@ class ASTBuilder {
 
   Type createSILBoxType(Type base);
   using BuiltSILBoxField = llvm::PointerIntPair<Type, 1>;
-  using BuiltSubstitution = std::pair<Type, Type>;
-  using BuiltRequirement = swift::Requirement;
   using BuiltLayoutConstraint = swift::LayoutConstraint;
   Type createSILBoxTypeWithLayout(ArrayRef<BuiltSILBoxField> Fields,
                                   ArrayRef<BuiltSubstitution> Substitutions,

include/swift/AST/AnyFunctionRef.h

@@ -179,12 +179,6 @@ class AnyFunctionRef {
     return TheFunction.dyn_cast<AbstractClosureExpr*>();
   }
 
-  bool isDeferBody() const {
-    if (auto *fd = dyn_cast_or_null<FuncDecl>(getAbstractFunctionDecl()))
-      return fd->isDeferBody();
-    return false;
-  }
-
   /// Return true if this closure is passed as an argument to a function and is
   /// known not to escape from that function.  In this case, captures can be
   /// more efficient.