Rename ExecutorRef to SerialExecutorRef

Author: ktoso

include/swift/ABI/Executor.h

@@ -54,7 +54,7 @@ class TaskExecutorWitnessTable;
 ///   bits off before accessing the witness table, so setting them
 ///   in the future should back-deploy as long as the witness table
 ///   reference is still present.
-class ExecutorRef {
+class SerialExecutorRef {
   HeapObject *Identity; // Not necessarily Swift reference-countable
   uintptr_t Implementation;
 
@@ -80,7 +80,7 @@ class ExecutorRef {
 
   static_assert(static_cast<uintptr_t>(ExecutorKind::Ordinary) == 0);
 
-  constexpr ExecutorRef(HeapObject *identity, uintptr_t implementation)
+  constexpr SerialExecutorRef(HeapObject *identity, uintptr_t implementation)
     : Identity(identity), Implementation(implementation) {}
 
 public:
@@ -89,35 +89,35 @@ class ExecutorRef {
   /// environment, it's presumed to be okay to switch synchronously
   /// to an actor.  As an executor request, this represents a request
   /// to drop whatever the current actor is.
-  constexpr static ExecutorRef generic() {
-    return ExecutorRef(nullptr, 0);
+  constexpr static SerialExecutorRef generic() {
+    return SerialExecutorRef(nullptr, 0);
   }
 
   /// Given a pointer to a default actor, return an executor reference
   /// for it.
-  static ExecutorRef forDefaultActor(DefaultActor *actor) {
+  static SerialExecutorRef forDefaultActor(DefaultActor *actor) {
     assert(actor);
-    return ExecutorRef(actor, 0);
+    return SerialExecutorRef(actor, 0);
   }
 
   /// Given a pointer to a serial executor and its SerialExecutor
   /// conformance, return an executor reference for it.
-  static ExecutorRef forOrdinary(HeapObject *identity,
+  static SerialExecutorRef forOrdinary(HeapObject *identity,
                            const SerialExecutorWitnessTable *witnessTable) {
     assert(identity);
     assert(witnessTable);
     auto wtable = reinterpret_cast<uintptr_t>(witnessTable) |
         static_cast<uintptr_t>(ExecutorKind::Ordinary);
-    return ExecutorRef(identity, wtable);
+    return SerialExecutorRef(identity, wtable);
   }
 
-  static ExecutorRef forComplexEquality(HeapObject *identity,
+  static SerialExecutorRef forComplexEquality(HeapObject *identity,
                                         const SerialExecutorWitnessTable *witnessTable) {
     assert(identity);
     assert(witnessTable);
     auto wtable = reinterpret_cast<uintptr_t>(witnessTable) |
                   static_cast<uintptr_t>(ExecutorKind::ComplexEquality);
-    return ExecutorRef(identity, wtable);
+    return SerialExecutorRef(identity, wtable);
   }
 
   HeapObject *getIdentity() const {
@@ -163,7 +163,7 @@ class ExecutorRef {
 
   /// Do we have to do any work to start running as the requested
   /// executor?
-  bool mustSwitchToRun(ExecutorRef newExecutor) const {
+  bool mustSwitchToRun(SerialExecutorRef newExecutor) const {
     return Identity != newExecutor.Identity;
   }
 
@@ -175,14 +175,18 @@ class ExecutorRef {
     return Implementation & WitnessTableMask;
   }
 
-  bool operator==(ExecutorRef other) const {
+  bool operator==(SerialExecutorRef other) const {
     return Identity == other.Identity;
   }
-  bool operator!=(ExecutorRef other) const {
+  bool operator!=(SerialExecutorRef other) const {
     return !(*this == other);
   }
 };
 
+/// Deprecated name for "SerialExecutorRef"; When it was first introduced it was ExecutorRef,
+/// but it always meant specifically a serial executor.
+typedef SerialExecutorRef ExecutorRef;
+
 class TaskExecutorRef {
   HeapObject *Identity; // Not necessarily Swift reference-countable
   uintptr_t Implementation;
@@ -250,7 +254,7 @@ class TaskExecutorRef {
 
 //  /// Do we have to do any work to start running as the requested
 //  /// executor?
-//  bool mustSwitchToRun(ExecutorRef newExecutor) const {
+//  bool mustSwitchToRun(TaskExecutorRef newExecutor) const {
 //    return Identity != newExecutor.Identity;
 //  }
 
@@ -267,10 +271,6 @@ class TaskExecutorRef {
   }
 };
 
-// Historically the 'ExecutorRef' was introduced initially, however it always has meant specifically
-// a SERIAL executor. This typedef fixes up this confusion and especially since now there is also a TaskExecutor.
-typedef ExecutorRef SerialExecutorRef;
-
 using JobInvokeFunction =
   SWIFT_CC(swiftasync)
   void (Job *);

include/swift/ABI/Task.h

@@ -400,7 +400,7 @@ class AsyncTask : public Job {
 public:
   /// Flag that the task is to be enqueued on the provided executor and actually
   /// enqueue it
-  void flagAsAndEnqueueOnExecutor(ExecutorRef newExecutor);
+  void flagAsAndEnqueueOnExecutor(SerialExecutorRef newExecutor);
 
   /// Flag that this task is now completed. This normally does not do anything
   /// but can be used to locally insert logging.
@@ -790,7 +790,7 @@ class ContinuationAsyncContext : public AsyncContext {
 
   /// The executor that should be resumed to.
   /// Public ABI.
-  ExecutorRef ResumeToExecutor;
+  SerialExecutorRef ResumeToExecutor;
 
 #if defined(SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
   /// In a task-to-thread model, instead of voluntarily descheduling the task

include/swift/ABI/TaskOptions.h

@@ -82,14 +82,14 @@ class TaskGroupTaskOptionRecord : public TaskOptionRecord {
 /// executor should be used instead, most often this may mean the global
 /// concurrent executor, or the enclosing actor's executor.
 class ExecutorTaskOptionRecord : public TaskOptionRecord {
-  const ExecutorRef Executor;
+  const SerialExecutorRef Executor;
 
 public:
-  ExecutorTaskOptionRecord(ExecutorRef executor)
+  ExecutorTaskOptionRecord(SerialExecutorRef executor)
     : TaskOptionRecord(TaskOptionRecordKind::Executor),
       Executor(executor) {}
 
-  ExecutorRef getExecutor() const {
+  SerialExecutorRef getExecutor() const {
     return Executor;
   }
 

include/swift/ABI/TaskStatus.h

@@ -321,7 +321,7 @@ class TaskDependencyStatusRecord : public TaskStatusRecord {
     // (potentially intrusively), so that the appropriate escalation effect
     // (which may be different for each type of executor) can happen if a task
     // is escalated while enqueued.
-    ExecutorRef Executor;
+    SerialExecutorRef Executor;
   } DependentOn;
 
   // Enum specifying the type of dependency this task has
@@ -359,7 +359,7 @@ class TaskDependencyStatusRecord : public TaskStatusRecord {
       DependentOn.TaskGroup = taskGroup;
   }
 
-  TaskDependencyStatusRecord(AsyncTask *waitingTask, ExecutorRef executor) :
+  TaskDependencyStatusRecord(AsyncTask *waitingTask, SerialExecutorRef executor) :
     TaskStatusRecord(TaskStatusRecordKind::TaskDependency),
         DependencyKind(EnqueuedOnExecutor), WaitingTask(waitingTask) {
       DependentOn.Executor = executor;
@@ -369,7 +369,7 @@ class TaskDependencyStatusRecord : public TaskStatusRecord {
     return record->getKind() == TaskStatusRecordKind::TaskDependency;
   }
 
-  void updateDependencyToEnqueuedOn(ExecutorRef executor) {
+  void updateDependencyToEnqueuedOn(SerialExecutorRef executor) {
     DependencyKind = EnqueuedOnExecutor;
     DependentOn.Executor = executor;
   }

include/swift/AST/Builtins.def

@@ -874,7 +874,7 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(Alignof, "alignof", "n", Special)
 
 // getCurrentExecutor: () async -> Builtin.Executor?
 //
-// Retrieve the ExecutorRef on which the current asynchronous
+// Retrieve the SerialExecutorRef on which the current asynchronous
 // function is executing, or nil if the function isn't running
 // anywhere in particular.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(GetCurrentExecutor, "getCurrentExecutor", "", Special)

include/swift/AST/Types.h

@@ -1693,7 +1693,7 @@ class BuiltinRawUnsafeContinuationType : public BuiltinType {
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinRawUnsafeContinuationType, BuiltinType)
 
 /// BuiltinExecutorType - The builtin executor-ref type.  In C, this
-/// is the ExecutorRef struct type.
+/// is the SerialExecutorRef struct type.
 class BuiltinExecutorType : public BuiltinType {
   friend class ASTContext;
   BuiltinExecutorType(const ASTContext &C)

include/swift/Runtime/Concurrency.h

@@ -660,7 +660,7 @@ void swift_task_localsCopyTo(AsyncTask* target);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
 void swift_task_switch(SWIFT_ASYNC_CONTEXT AsyncContext *resumeToContext,
                        TaskContinuationFunction *resumeFunction,
-                       ExecutorRef newExecutor);
+                       SerialExecutorRef newExecutor);
 
 /// Mark a task for enqueue on a new executor and then enqueue it.
 ///
@@ -671,7 +671,7 @@ void swift_task_switch(SWIFT_ASYNC_CONTEXT AsyncContext *resumeToContext,
 /// synchronously when possible.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void
-swift_task_enqueueTaskOnExecutor(AsyncTask *task, ExecutorRef executor);
+swift_task_enqueueTaskOnExecutor(AsyncTask *task, SerialExecutorRef executor);
 
 /// Enqueue the given job to run asynchronously on the given executor.
 ///
@@ -681,7 +681,7 @@ swift_task_enqueueTaskOnExecutor(AsyncTask *task, ExecutorRef executor);
 /// Generally you should call swift_task_switch to switch execution
 /// synchronously when possible.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-void swift_task_enqueue(Job *job, ExecutorRef executor);
+void swift_task_enqueue(Job *job, SerialExecutorRef executor);
 
 /// Enqueue the given job to run asynchronously on the global
 /// execution pool.
@@ -716,7 +716,7 @@ bool swift_task_isOnExecutor(
     const SerialExecutorWitnessTable *wtable);
 
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-bool swift_executor_isComplexEquality(ExecutorRef ref);
+bool swift_executor_isComplexEquality(SerialExecutorRef ref);
 
 /// Return the 64bit TaskID (if the job is an AsyncTask),
 /// or the 32bits of the job Id otherwise.
@@ -886,27 +886,27 @@ void swift_task_asyncMainDrainQueue [[noreturn]]();
 /// Establish that the current thread is running as the given
 /// executor, then run a job.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-void swift_job_run(Job *job, ExecutorRef executor);
+void swift_job_run(Job *job, SerialExecutorRef executor);
 
 /// Return the current thread's active task reference.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTask *swift_task_getCurrent(void);
 
 /// Return the current thread's active executor reference.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-ExecutorRef swift_task_getCurrentExecutor(void);
+SerialExecutorRef swift_task_getCurrentExecutor(void);
 
 /// Return the main-actor executor reference.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-ExecutorRef swift_task_getMainExecutor(void);
+SerialExecutorRef swift_task_getMainExecutor(void);
 
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-bool swift_task_isCurrentExecutor(ExecutorRef executor);
+bool swift_task_isCurrentExecutor(SerialExecutorRef executor);
 
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_reportUnexpectedExecutor(
     const unsigned char *file, uintptr_t fileLength, bool fileIsASCII,
-    uintptr_t line, ExecutorRef executor);
+    uintptr_t line, SerialExecutorRef executor);
 
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 JobPriority swift_task_getCurrentThreadPriority(void);

include/swift/Runtime/RuntimeFunctions.def

@@ -2310,7 +2310,7 @@ FUNCTION(TaskCreate,
 
 // void swift_task_switch(AsyncContext *resumeContext,
 //                        TaskContinuationFunction *resumeFunction,
-//                        ExecutorRef newExecutor);
+//                        SerialExecutorRef newExecutor);
 FUNCTION(TaskSwitchFunc,
          swift_task_switch, SwiftAsyncCC,
          ConcurrencyAvailability,
@@ -2372,7 +2372,7 @@ FUNCTION(ContinuationThrowingResumeWithError,
          EFFECT(Concurrency),
          UNKNOWN_MEMEFFECTS)
 
-// ExecutorRef swift_task_getCurrentExecutor();
+// SerialExecutorRef swift_task_getCurrentExecutor();
 FUNCTION(TaskGetCurrentExecutor,
          swift_task_getCurrentExecutor, SwiftCC,
          ConcurrencyAvailability,
@@ -2382,7 +2382,7 @@ FUNCTION(TaskGetCurrentExecutor,
          EFFECT(Concurrency),
          MEMEFFECTS(ArgMemOnly))
 
-// ExecutorRef swift_task_getMainExecutor();
+// SerialExecutorRef swift_task_getMainExecutor();
 FUNCTION(TaskGetMainExecutor,
          swift_task_getMainExecutor, SwiftCC,
          ConcurrencyAvailability,

include/swift/Strings.h

@@ -149,7 +149,7 @@ constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_UNSAFEVALUEBUFFER =
 /// The name of the Builtin type for Job
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_JOB = {
     "Builtin.Job"};
-/// The name of the Builtin type for ExecutorRef
+/// The name of the Builtin type for SerialExecutorRef
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_EXECUTOR = {
     "Builtin.Executor"};
 /// The name of the Builtin type for DefaultActorStorage

lib/IRGen/GenCall.cpp

@@ -1925,7 +1925,7 @@ llvm::Type *SignatureExpansion::getErrorRegisterType() {
 
 void SignatureExpansion::expandAsyncReturnType() {
   // Build up the signature of the return continuation function.
-  // void (AsyncTask *, ExecutorRef, AsyncContext *, DirectResult0, ...,
+  // void (AsyncTask *, SerialExecutorRef, AsyncContext *, DirectResult0, ...,
   //                                                 DirectResultN, Error*);
   ResultIRType = IGM.VoidTy;
   addAsyncParameters();