[Concurrency] Ensure that enqueue(partialTask:) is first in actor vtables.

Actor classes never have non-actor superclasses, so we can ensure that
all actor classes have a common vtable prefix for the
`enqueue(partialTask:)` operation. This allows us to treat all actor
classes uniformly, without having to go through the Actor witness
table every time.

Author: DougGregor

include/swift/AST/Decl.h

@@ -6329,6 +6329,14 @@ class FuncDecl : public AbstractFunctionDecl {
 
   bool isMainTypeMainMethod() const;
 
+  /// Whether the given name is enqueue(partialTask:), which is used for
+  /// actors.
+  static bool isEnqueuePartialTaskName(ASTContext &ctx, DeclName name);
+
+  /// Determine whether this function is the witness to the Actor protocol's
+  /// enqueue(partialTask:) operation within an actor.
+  bool isActorEnqueuePartialTaskWitness() const;
+
   SelfAccessKind getSelfAccessKind() const;
 
   void setSelfAccessKind(SelfAccessKind mod) {

lib/AST/Decl.cpp

@@ -7508,6 +7508,56 @@ bool FuncDecl::isMainTypeMainMethod() const {
          getParameters()->size() == 0;
 }
 
+bool FuncDecl::isEnqueuePartialTaskName(ASTContext &ctx, DeclName name) {
+  if (name.isCompoundName() && name.getBaseName() == ctx.Id_enqueue) {
+    auto argumentNames = name.getArgumentNames();
+    return argumentNames.size() == 1 && argumentNames[0] == ctx.Id_partialTask;
+  }
+
+  return false;
+}
+
+bool FuncDecl::isActorEnqueuePartialTaskWitness() const {
+  if (!isEnqueuePartialTaskName(getASTContext(), getName()))
+    return false;
+
+  auto classDecl = getDeclContext()->getSelfClassDecl();
+  if (!classDecl)
+    return false;
+
+  if (!classDecl->isActor())
+    return false;
+
+  ASTContext &ctx = getASTContext();
+  auto actorProto = ctx.getProtocol(KnownProtocolKind::Actor);
+  if (!actorProto)
+    return false;
+
+  FuncDecl *requirement = nullptr;
+  for (auto protoMember : actorProto->getParsedMembers()) {
+    if (auto protoFunc = dyn_cast<FuncDecl>(protoMember)) {
+      if (isEnqueuePartialTaskName(ctx, protoFunc->getName())) {
+        requirement = protoFunc;
+        break;
+      }
+    }
+  }
+
+  if (!requirement)
+    return false;
+
+  SmallVector<ProtocolConformance *, 1> conformances;
+  classDecl->lookupConformance(
+      classDecl->getModuleContext(), actorProto, conformances);
+  for (auto conformance : conformances) {
+    auto witness = conformance->getWitnessDecl(requirement);
+    if (witness == this)
+      return true;
+  }
+
+  return false;
+}
+
 ConstructorDecl::ConstructorDecl(DeclName Name, SourceLoc ConstructorLoc,
                                  bool Failable, SourceLoc FailabilityLoc,
                                  bool Throws,

lib/Sema/DerivedConformanceActor.cpp

@@ -287,7 +287,7 @@ ValueDecl *DerivedConformance::deriveActor(ValueDecl *requirement) {
   if (!func)
     return nullptr;
 
-  if (isEnqueuePartialTask(Context, func->getName()))
+  if (FuncDecl::isEnqueuePartialTaskName(Context, func->getName()))
     return deriveActor_enqueuePartialTask(*this);
 
   return nullptr;

lib/Sema/DerivedConformances.cpp

@@ -365,7 +365,7 @@ ValueDecl *DerivedConformance::getDerivableRequirement(NominalTypeDecl *nominal,
     }
 
     // Actor.enqueue(partialTask: PartialTask)
-    if (isEnqueuePartialTask(ctx, name)) {
+    if (FuncDecl::isEnqueuePartialTaskName(ctx, name)) {
       return getRequirement(KnownProtocolKind::Actor);
     }
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -749,12 +749,3 @@ ActorIsolation swift::getActorIsolation(ValueDecl *value) {
       ctx.evaluator, ActorIsolationRequest{value},
       ActorIsolation::forUnspecified());
 }
-
-bool swift::isEnqueuePartialTask(ASTContext &ctx, DeclName name) {
-  if (name.isCompoundName() && name.getBaseName() == ctx.Id_enqueue) {
-    auto argumentNames = name.getArgumentNames();
-    return argumentNames.size() == 1 && argumentNames[0] == ctx.Id_partialTask;
-  }
-
-  return false;
-}

lib/Sema/TypeCheckConcurrency.h

@@ -23,7 +23,6 @@ class ActorIsolation;
 class ASTContext;
 class ClassDecl;
 class DeclContext;
-class DeclName;
 class Expr;
 class FuncDecl;
 class ValueDecl;
@@ -38,9 +37,6 @@ void checkActorIsolation(const Expr *expr, const DeclContext *dc);
 /// Determine how the given value declaration is isolated.
 ActorIsolation getActorIsolation(ValueDecl *value);
 
-/// Whether the given declaration name is enqueue(partialTask:).
-bool isEnqueuePartialTask(ASTContext &ctx, DeclName name);
-
 } // end namespace swift
 
 #endif /* SWIFT_SEMA_TYPECHECKCONCURRENCY_H */

lib/Sema/TypeCheckDecl.cpp

@@ -2704,6 +2704,15 @@ SemanticMembersRequest::evaluate(Evaluator &evaluator,
 
   for (auto *member : idc->getMembers()) {
     if (auto *afd = dyn_cast<AbstractFunctionDecl>(member)) {
+      // If this is a witness to Actor.enqueue(partialTask:), put it at the
+      // beginning of the vtable.
+      if (auto func = dyn_cast<FuncDecl>(afd)) {
+        if (func->isActorEnqueuePartialTaskWitness()) {
+          result.insert(result.begin(), func);
+          continue;
+        }
+      }
+
       // Add synthesized members to a side table and sort them by their mangled
       // name, since they could have been added to the class in any order.
       if (afd->isSynthesized()) {

lib/Sema/TypeCheckProtocol.cpp

@@ -4219,10 +4219,12 @@ void ConformanceChecker::resolveValueWitnesses() {
       auto &C = witness->getASTContext();
 
       // Ensure that Actor.enqueue(partialTask:) is implemented within the
-      // class itself.
-      if (isEnqueuePartialTask(C, requirement->getName()) &&
+      // actor class itself.
+      if (FuncDecl::isEnqueuePartialTaskName(C, requirement->getName()) &&
           Proto->isSpecificProtocol(KnownProtocolKind::Actor) &&
-          DC != witness->getDeclContext()) {
+          DC != witness->getDeclContext() &&
+          Adoptee->getClassOrBoundGenericClass() &&
+          Adoptee->getClassOrBoundGenericClass()->isActor()) {
         witness->diagnose(diag::enqueue_partial_task_not_in_context, Adoptee);
         return;
       }

test/SILGen/synthesized_conformance_actor.swift

@@ -16,20 +16,17 @@ public actor class A1<T: DefaultInit> {
 
 extension Int: DefaultInit { }
 
+public actor class A2 {
+  func f() { }
+  @actorIndependent public func enqueue(partialTask: PartialAsyncTask) { }
+}
+
 func buildIt() {
   _ = A1<Int>()
 }
 
-// variable initialization expression of A1.$__actor_storage
-// CHECK-LABEL: sil hidden [transparent] [ossa] @$s29synthesized_conformance_actor2A1C03$__C8_storage33_550E67F1F00BFF89F882603E5B70A41BLL12_Concurrency17_NativeActorQueueVvpfi : $@convention(thin) <T where T : DefaultInit> () -> @out _NativeActorQueue {
-// CHECK: bb0([[PROPERTY:%.*]] : $*_NativeActorQueue):
-// CHECK-NEXT: [[META:%.*]] = metatype $@thick A1<T>.Type
-// CHECK-NEXT: [[ERASED_META:%.*]] = init_existential_metatype [[META]] : $@thick A1<T>.Type, $@thick AnyObject.Type
-// CHECK: [[INIT_FN:%.*]] = function_ref @$s12_Concurrency24_defaultActorQueueCreateyAA07_NativecD0VyXlXpF : $@convention(thin) (@thick AnyObject.Type) -> @out _NativeActorQueue
-// CHECK-NEXT: = apply [[INIT_FN]]([[PROPERTY]], [[ERASED_META]]) : $@convention(thin) (@thick AnyObject.Type) -> @out _NativeActorQueue
-
 // A1.enqueue(partialTask:)
-// CHECK-LABEL: sil hidden [ossa] @$s29synthesized_conformance_actor2A1C7enqueue11partialTasky12_Concurrency012PartialAsyncG0V_tF : $@convention(method) <T where T : DefaultInit> (@in_guaranteed PartialAsyncTask, @guaranteed A1<T>) -> () {
+// CHECK-LABEL: sil [ossa] @$s29synthesized_conformance_actor2A1C7enqueue11partialTasky12_Concurrency012PartialAsyncG0V_tF : $@convention(method) <T where T : DefaultInit> (@in_guaranteed PartialAsyncTask, @guaranteed A1<T>) -> () {
 // CHECK: bb0([[PARTIAL_TASK:%.*]] : $*PartialAsyncTask, [[SELF:%.*]] : @guaranteed $A1<T>):
 // CHECK:       [[SELF_COPY:%.*]] = copy_value [[SELF]] : $A1<T>
 // CHECK-NEXT:  [[SELF_ANY_OBJECT:%.*]] = init_existential_ref [[SELF_COPY]] : $A1<T> : $A1<T>, $AnyObject
@@ -39,3 +36,18 @@ func buildIt() {
 // CHECK:       [[ENQUEUE_FN:%.*]] = function_ref @$s12_Concurrency36_defaultActorQueueEnqueuePartialTask5actor5queue07partialG0yyXl_AA07_NativecD0VzAA0f5AsyncG0VtF : $@convention(thin) (@guaranteed AnyObject, @inout _NativeActorQueue, @in_guaranteed PartialAsyncTask) -> ()
 // CHECK-NEXT:  apply [[ENQUEUE_FN]]([[SELF_ANY_OBJECT]], [[DYNAMIC_ACCESS]], [[PARTIAL_TASK]]) : $@convention(thin) (@guaranteed AnyObject, @inout _NativeActorQueue, @in_guaranteed PartialAsyncTask) -> ()
 // CHECK-NEXT:  end_access [[DYNAMIC_ACCESS]] : $*_NativeActorQueue
+
+// variable initialization expression of A1.$__actor_storage
+// CHECK-LABEL: sil [transparent] [ossa] @$s29synthesized_conformance_actor2A1C03$__C8_storage33{{.*}}12_Concurrency17_NativeActorQueueVvpfi : $@convention(thin) <T where T : DefaultInit> () -> @out _NativeActorQueue {
+// CHECK: bb0([[PROPERTY:%.*]] : $*_NativeActorQueue):
+// CHECK-NEXT: [[META:%.*]] = metatype $@thick A1<T>.Type
+// CHECK-NEXT: [[ERASED_META:%.*]] = init_existential_metatype [[META]] : $@thick A1<T>.Type, $@thick AnyObject.Type
+// CHECK: [[INIT_FN:%.*]] = function_ref @$s12_Concurrency24_defaultActorQueueCreateyAA07_NativecD0VyXlXpF : $@convention(thin) (@thick AnyObject.Type) -> @out _NativeActorQueue
+// CHECK-NEXT: = apply [[INIT_FN]]([[PROPERTY]], [[ERASED_META]]) : $@convention(thin) (@thick AnyObject.Type) -> @out _NativeActorQueue
+
+// Ensure that enqueue(partialTask:) is the first slot in the vtable.
+// CHECK-LABEL: sil_vtable [serialized] A1 {
+// CHECK-NEXT:    #A1.enqueue: <T where T : DefaultInit> (A1<T>) -> (PartialAsyncTask) -> () : @$s29synthesized_conformance_actor2A1C7enqueue11partialTasky12_Concurrency012PartialAsyncG0V_tF
+
+// CHECK-LABEL: sil_vtable [serialized] A2 {
+// CHECK-NEXT:    #A2.enqueue: (A2) -> (PartialAsyncTask) -> () : @$s29synthesized_conformance_actor2A2C7enqueue11partialTasky12_Concurrency012PartialAsyncG0V_tF // A2.enqueue(partialTask:)