Introduce basic support for custom executors.

- Introduce an UnownedSerialExecutor type into the concurrency library.
- Create a SerialExecutor protocol which allows an executor type to
  change how it executes jobs.
- Add an unownedExecutor requirement to the Actor protocol.
- Change the ABI for ExecutorRef so that it stores a SerialExecutor
  witness table pointer in the implementation field.  This effectively
  makes ExecutorRef an `unowned(unsafe) SerialExecutor`, except that
  default actors are represented without a witness table pointer (just
  a bit-pattern).
- Synthesize the unownedExecutor method for default actors (i.e. actors
  that don't provide an unownedExecutor property).
- Make synthesized unownedExecutor properties `final`, and give them
  a semantics attribute specifying that they're for default actors.
- Split `Builtin.buildSerialExecutorRef` into a few more precise
  builtins.  We're not using the main-actor one yet, though.

Pitch thread:
  https://forums.swift.org/t/support-custom-executors-in-swift-concurrency/44425

Author: rjmccall

include/swift/ABI/Executor.h

@@ -27,6 +27,7 @@ class AsyncContext;
 class AsyncTask;
 class DefaultActor;
 class Job;
+class SerialExecutorWitnessTable;
 
 /// FIXME: only exists for the quick-and-dirty MainActor implementation.
 SWIFT_EXPORT_FROM(swift_Concurrency)
@@ -46,6 +47,10 @@ class ExecutorRef {
   HeapObject *Identity; // Not necessarily Swift reference-countable
   uintptr_t Implementation;
 
+  enum: uintptr_t {
+    WitnessTableMask = ~uintptr_t(alignof(void*) - 1)
+  };
+
   constexpr ExecutorRef(HeapObject *identity, uintptr_t implementation)
     : Identity(identity), Implementation(implementation) {}
 
@@ -58,18 +63,6 @@ class ExecutorRef {
     return ExecutorRef(nullptr, 0);
   }
 
-  /// FIXME: only exists for the quick-and-dirty MainActor implementation.
-  /// NOTE: I didn't go with Executor::forMainActor(DefaultActor*) because
-  /// __swift_run_job_main_executor can't take more than one argument.
-  static ExecutorRef mainExecutor() {
-    auto identity = getMainActorIdentity();
-    return ExecutorRef(identity, 0);
-  }
-  static HeapObject *getMainActorIdentity() {
-    return reinterpret_cast<HeapObject*>(
-                                   ExecutorRefFlags::MainActorIdentity);
-  }
-
   /// Given a pointer to a default actor, return an executor reference
   /// for it.
   static ExecutorRef forDefaultActor(DefaultActor *actor) {
@@ -86,18 +79,6 @@ class ExecutorRef {
     return Identity == 0;
   }
 
-  /// FIXME: only exists for the quick-and-dirty MainActor implementation.
-  bool isMainExecutor() const {
-    if (Identity == getMainActorIdentity())
-      return true;
-
-    if (Identity == nullptr || MainActorMetadata == nullptr)
-      return false;
-
-    Metadata const* metadata = swift_getObjectType(Identity);
-    return metadata == MainActorMetadata;
-  }
-
   /// Is this a default-actor executor reference?
   bool isDefaultActor() const {
     return Implementation & unsigned(ExecutorRefFlags::DefaultActor);
@@ -107,16 +88,20 @@ class ExecutorRef {
     return reinterpret_cast<DefaultActor*>(Identity);
   }
 
+  const SerialExecutorWitnessTable *getSerialExecutorWitnessTable() const {
+    assert(!isGeneric() && !isDefaultActor());
+    auto table = Implementation & WitnessTableMask;
+    return reinterpret_cast<const SerialExecutorWitnessTable*>(table);
+  }
+
   /// Do we have to do any work to start running as the requested
   /// executor?
   bool mustSwitchToRun(ExecutorRef newExecutor) const {
     return Identity != newExecutor.Identity;
   }
 
   bool operator==(ExecutorRef other) const {
-    return Identity == other.Identity
-    /// FIXME: only exists for the quick-and-dirty MainActor implementation.
-          || (isMainExecutor() && other.isMainExecutor());
+    return Identity == other.Identity;
   }
   bool operator!=(ExecutorRef other) const {
     return !(*this == other);

include/swift/ABI/MetadataValues.h

@@ -2195,10 +2195,7 @@ enum class ExecutorRefFlags : size_t {
   // pointer
 
   /// The executor is a default actor.
-  DefaultActor = 0x1,
-
-  /// TODO: remove this
-  MainActorIdentity = 0x2,
+  DefaultActor = 0x1
 };
 
 } // end namespace swift

include/swift/AST/ASTSynthesis.h

@@ -49,6 +49,7 @@ enum SingletonTypeSynthesizer {
   _rawUnsafeContinuation,
   _void,
   _word,
+  _serialExecutor,
 };
 inline Type synthesizeType(SynthesisContext &SC,
                            SingletonTypeSynthesizer kind) {
@@ -65,6 +66,9 @@ inline Type synthesizeType(SynthesisContext &SC,
   case _void: return SC.Context.TheEmptyTupleType;
   case _word: return BuiltinIntegerType::get(BuiltinIntegerWidth::pointer(),
                                              SC.Context);
+  case _serialExecutor:
+    return SC.Context.getProtocol(KnownProtocolKind::SerialExecutor)
+      ->getDeclaredInterfaceType();
   }
 }
 

include/swift/AST/Builtins.def

@@ -736,10 +736,6 @@ BUILTIN_MISC_OPERATION(ResumeThrowingContinuationReturning,
 BUILTIN_MISC_OPERATION(ResumeThrowingContinuationThrowing,
                        "resumeThrowingContinuationThrowing", "", Special)
 
-/// Build a Builtin.Executor value from the given serial executor reference.
-BUILTIN_MISC_OPERATION(BuildSerialExecutorRef,
-                       "buildSerialExecutorRef", "", Special)
-
 /// Create a task group.
 BUILTIN_MISC_OPERATION(CreateTaskGroup,
                        "createTaskGroup", "", Special)
@@ -835,6 +831,19 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(AutoDiffProjectTopLevelSubcontext, "autoDiffP
 // autoDiffAllocateSubcontext: (Builtin.NativeObject, Builtin.Word) -> Builtin.RawPointer
 BUILTIN_MISC_OPERATION_WITH_SILGEN(AutoDiffAllocateSubcontext, "autoDiffAllocateSubcontext", "", Special)
 
+/// Build a Builtin.Executor value from an "ordinary" serial executor
+/// reference.
+BUILTIN_MISC_OPERATION_WITH_SILGEN(BuildOrdinarySerialExecutorRef,
+                                   "buildOrdinarySerialExecutorRef", "n", Special)
+
+/// Build a Builtin.Executor value from a default actor reference.
+BUILTIN_MISC_OPERATION_WITH_SILGEN(BuildDefaultActorExecutorRef,
+                                   "buildDefaultActorExecutorRef", "n", Special)
+
+/// Build a Builtin.Executor value for the main actor.
+BUILTIN_MISC_OPERATION_WITH_SILGEN(BuildMainActorExecutorRef,
+                                   "buildMainActorExecutorRef", "n", Special)
+
 #undef BUILTIN_MISC_OPERATION_WITH_SILGEN
 
 #undef BUILTIN_MISC_OPERATION

include/swift/AST/Decl.h

@@ -3778,9 +3778,8 @@ class ClassDecl final : public NominalTypeDecl {
   /// Get the closest-to-root superclass that's an actor class.
   const ClassDecl *getRootActorClass() const;
 
-  /// Does this class explicitly declare any of the methods that
-  /// would prevent it from being a default actor?
-  bool hasExplicitCustomActorMethods() const;
+  /// Fetch this class's unownedExecutor property, if it has one.
+  const VarDecl *getUnownedExecutorProperty() const;
 
   /// Is this the NSObject class type?
   bool isNSObject() const;
@@ -4006,6 +4005,7 @@ enum class KnownDerivableProtocolKind : uint8_t {
   Decodable,
   AdditiveArithmetic,
   Differentiable,
+  Actor,
 };
 
 /// ProtocolDecl - A declaration of a protocol, for example:

include/swift/AST/DiagnosticsSema.def

@@ -4354,6 +4354,13 @@ ERROR(async_objc_dynamic_self,none,
 ERROR(actor_inheritance,none,
       "actor types do not support inheritance", ())
 
+ERROR(unowned_executor_outside_actor,none,
+      "'unownedExecutor' can only be implemented within the main "
+      "definition of an actor", ())
+ERROR(override_implicit_unowned_executor,none,
+      "cannot override an actor's 'unownedExecutor' property that wasn't "
+      "explicitly defined", ())
+
 ERROR(actor_isolated_non_self_reference,none,
         "actor-isolated %0 %1 can only be %select{referenced|mutated|used 'inout'}3 "
         "%select{from inside the actor|on 'self'}2",

include/swift/AST/KnownIdentifiers.def

@@ -218,6 +218,7 @@ IDENTIFIER(className)
 
 IDENTIFIER(_defaultActorInitialize)
 IDENTIFIER(_defaultActorDestroy)
+IDENTIFIER(unownedExecutor)
 
 IDENTIFIER_(ErrorType)
 IDENTIFIER(Code)

include/swift/AST/KnownProtocols.def

@@ -72,6 +72,7 @@ PROTOCOL(CaseIterable)
 PROTOCOL(SIMDScalar)
 PROTOCOL(BinaryInteger)
 PROTOCOL(RangeReplaceableCollection)
+PROTOCOL(SerialExecutor)
 
 PROTOCOL_(BridgedNSError)
 PROTOCOL_(BridgedStoredNSError)

include/swift/AST/KnownSDKTypes.def

@@ -39,6 +39,7 @@ KNOWN_SDK_TYPE_DECL(ObjectiveC, ObjCBool, StructDecl, 0)
 // standardized
 KNOWN_SDK_TYPE_DECL(Concurrency, UnsafeContinuation, NominalTypeDecl, 2)
 KNOWN_SDK_TYPE_DECL(Concurrency, MainActor, NominalTypeDecl, 0)
+KNOWN_SDK_TYPE_DECL(Concurrency, UnownedSerialExecutor, NominalTypeDecl, 0)
 
 KNOWN_SDK_TYPE_DECL(Concurrency, TaskLocal, ClassDecl, 1)
 

include/swift/Basic/Features.def

@@ -43,9 +43,10 @@ LANGUAGE_FEATURE(RethrowsProtocol, 0, "@rethrows protocol", true)
 LANGUAGE_FEATURE(GlobalActors, 0, "Global actors", langOpts.EnableExperimentalConcurrency)
 LANGUAGE_FEATURE(BuiltinJob, 0, "Builtin.Job type", true)
 LANGUAGE_FEATURE(Sendable, 0, "Sendable and @Sendable", true)
-LANGUAGE_FEATURE(BuiltinExecutor, 0, "Executor builtins", true)
+LANGUAGE_FEATURE(BuiltinExecutor, 0, "Builtin.Executor type", true)
 LANGUAGE_FEATURE(BuiltinContinuation, 0, "Continuation builtins", true)
 LANGUAGE_FEATURE(BuiltinTaskGroup, 0, "TaskGroup builtins", true)
 LANGUAGE_FEATURE(InheritActorContext, 0, "@_inheritActorContext attribute", true)
+LANGUAGE_FEATURE(BuiltinBuildExecutor, 0, "Executor-building builtins", true)
 
 #undef LANGUAGE_FEATURE