[Concurrency] Implicitly synthesize actor queue storage and enqueue.

When an actor class has its `enqueue(partialTask:)` implicitly
synthesized, also synthesize a stored property for the actor's queue.
The type of the property is defined by the _Concurrency library
(`_DefaultActorQueue`), and it will be initialized with a call to
`_defaultActorQueueCreate` (also provided by the _Concurrency
library).

Also synthesize the body of the implicitly-generated
`enqueue(partialTask:)`, which will be a call to
`_defaultActorQueueEnqueuePartialTask(actor:queue:partialTask:)`.
Together, all of these allow us to experiment with the form of the
queue and the queue operation without affecting the type checker.

When `enqueue(partialTask:)` is not implicitly synthesized, the queue
storage is not synthesized either. In such cases, the user has taken
over the execution of tasks for the actor, rather than using the
default implementation.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4195,9 +4195,9 @@ ERROR(actorisolated_not_actor_instance_member,none,
       "'@actorIsolated' can only be applied to instance members of actors",
       ())
 
-ERROR(partial_task_type_missing,none,
-      "missing 'PartialAsyncTask' type, probably because the '_Concurrency' "
-      "module was not imported", ())
+ERROR(concurrency_lib_missing,none,
+      "missing '%0' declaration, probably because the '_Concurrency' "
+      "module was not imported", (StringRef))
 ERROR(enqueue_partial_task_not_in_context,none,
       "'enqueue(partialTask:)' can only be implemented in the definition of "
       "actor class %0", (Type))

include/swift/AST/KnownIdentifiers.def

@@ -141,6 +141,7 @@ IDENTIFIER(withKeywordArguments)
 IDENTIFIER(wrapped)
 IDENTIFIER(wrappedValue)
 IDENTIFIER(wrapperValue)
+IDENTIFIER_WITH_NAME(actorStorage, "$__actor_storage")
 
 // Kinds of layout constraints
 IDENTIFIER_WITH_NAME(UnknownLayout, "_UnknownLayout")

lib/Sema/DerivedConformanceActor.cpp

@@ -15,6 +15,8 @@
 //===----------------------------------------------------------------------===//
 #include "DerivedConformances.h"
 #include "TypeChecker.h"
+#include "TypeCheckConcurrency.h"
+#include "swift/AST/NameLookupRequests.h"
 #include "swift/AST/ParameterList.h"
 
 using namespace swift;
@@ -46,49 +48,237 @@ static Type getPartialAsyncTaskType(ASTContext &ctx) {
   return Type();
 }
 
+/// Look for the default actor queue type.
+static Type getDefaultActorQueueType(DeclContext *dc, SourceLoc loc) {
+  ASTContext &ctx = dc->getASTContext();
+  UnqualifiedLookupOptions options;
+  options |= UnqualifiedLookupFlags::TypeLookup;
+  auto desc = UnqualifiedLookupDescriptor(
+      DeclNameRef(ctx.getIdentifier("_DefaultActorQueue")), dc, loc, options);
+  auto lookup =
+      evaluateOrDefault(ctx.evaluator, UnqualifiedLookupRequest{desc}, {});
+  for (const auto &result : lookup) {
+    if (auto typeDecl = dyn_cast<TypeDecl>(result.getValueDecl()))
+      return typeDecl->getDeclaredInterfaceType();
+  }
+
+  return Type();
+}
+
+/// Look for the initialization function for the default actor storage.
+static FuncDecl *getDefaultActorQueueCreate(DeclContext *dc, SourceLoc loc) {
+  ASTContext &ctx = dc->getASTContext();
+  auto desc = UnqualifiedLookupDescriptor(
+      DeclNameRef(ctx.getIdentifier("_defaultActorQueueCreate")), dc, loc,
+      UnqualifiedLookupOptions());
+  auto lookup =
+      evaluateOrDefault(ctx.evaluator, UnqualifiedLookupRequest{desc}, {});
+  for (const auto &result : lookup) {
+    // FIXME: Validate this further, because we're assuming the exact type.
+    if (auto func = dyn_cast<FuncDecl>(result.getValueDecl()))
+      return func;
+  }
+
+  return nullptr;
+}
+
+/// Look for the default enqueue operation.
+static FuncDecl *getDefaultActorQueueEnqueue(DeclContext *dc, SourceLoc loc) {
+  ASTContext &ctx = dc->getASTContext();
+  auto desc = UnqualifiedLookupDescriptor(
+      DeclNameRef(ctx.getIdentifier("_defaultActorQueueEnqueuePartialTask")),
+      dc, loc, UnqualifiedLookupOptions());
+  auto lookup =
+      evaluateOrDefault(ctx.evaluator, UnqualifiedLookupRequest{desc}, {});
+  for (const auto &result : lookup) {
+    // FIXME: Validate this further, because we're assuming the exact type.
+    if (auto func = dyn_cast<FuncDecl>(result.getValueDecl()))
+      return func;
+  }
+
+  return nullptr;
+}
+
 static std::pair<BraceStmt *, bool>
 deriveBodyActor_enqueuePartialTask(
   AbstractFunctionDecl *enqueuePartialTask, void *) {
+  // func enqueue(partialTask: PartialAsyncTask) {
+  //   _defaultActorQueueEnqueuePartialTask(
+  //     actor: self, queue: &self.$__actor_storage, partialTask: partialTask)
+  // }
   ASTContext &ctx = enqueuePartialTask->getASTContext();
 
-  // FIXME: Call into runtime API to enqueue the task, once we figure out
-  // what that runtime API should look like.
+  // Dig out the $__actor_storage property.
+  auto classDecl = enqueuePartialTask->getDeclContext()->getSelfClassDecl();
+  VarDecl *storageVar = nullptr;
+  for (auto decl : classDecl->lookupDirect(ctx.Id_actorStorage)) {
+    storageVar = dyn_cast<VarDecl>(decl);
+    if (storageVar)
+      break;
+  }
+
+  // Produce an empty brace statement on failure.
+  auto failure = [&]() -> std::pair<BraceStmt *, bool> {
+    auto body = BraceStmt::create(
+        ctx, SourceLoc(), { }, SourceLoc(), /*implicit=*/true);
+    return { body, /*isTypeChecked=*/true };
+  };
+
+  if (!storageVar) {
+    classDecl->diagnose(
+        diag::concurrency_lib_missing, ctx.Id_actorStorage.str());
+    return failure();
+  }
+
+  // Call into the runtime to enqueue the task.
+  auto fn = getDefaultActorQueueEnqueue(classDecl, classDecl->getLoc());
+  if (!fn) {
+    classDecl->diagnose(
+        diag::concurrency_lib_missing, "_defaultActorQueueEnqueuePartialTask");
+    return failure();
+  }
+
+  // Reference to _defaultActorQueueEnqueuePartialTask.
+  auto fnRef = new (ctx) DeclRefExpr(fn, DeclNameLoc(), /*Implicit=*/true);
+  fnRef->setType(fn->getInterfaceType());
+
+  // self argument to the function.
+  auto selfDecl = enqueuePartialTask->getImplicitSelfDecl();
+  Type selfType = enqueuePartialTask->mapTypeIntoContext(
+      selfDecl->getValueInterfaceType());
+  Expr *selfArg = new (ctx) DeclRefExpr(
+      selfDecl, DeclNameLoc(), /*Implicit=*/true, AccessSemantics::Ordinary,
+      selfType);
+  selfArg = ErasureExpr::create(ctx, selfArg, ctx.getAnyObjectType(), { });
+  selfArg->setImplicit();
+
+  // Address of the actor storage.
+  auto module = classDecl->getModuleContext();
+  Expr *selfBase = new (ctx) DeclRefExpr(
+      selfDecl, DeclNameLoc(), /*Implicit=*/true, AccessSemantics::Ordinary,
+      selfType);
+  SubstitutionMap storageVarSubs = classDecl->getDeclaredTypeInContext()
+      ->getMemberSubstitutionMap(module, storageVar);
+  ConcreteDeclRef storageVarDeclRef(storageVar, storageVarSubs);
+  Type storageVarType = classDecl->mapTypeIntoContext(
+      storageVar->getValueInterfaceType());
+  Type storageVarRefType = LValueType::get(storageVarType);
+  Expr *storageVarRefExpr = new (ctx) MemberRefExpr(
+      selfBase, SourceLoc(), storageVarDeclRef, DeclNameLoc(),
+      /*Implicit=*/true);
+  storageVarRefExpr->setType(storageVarRefType);
+  storageVarRefExpr = new (ctx) InOutExpr(
+      SourceLoc(), storageVarRefExpr, storageVarType, /*isImplicit=*/true);
+
+  // The partial asynchronous task.
+  auto partialTaskParam = enqueuePartialTask->getParameters()->get(0);
+  Expr *partialTask = new (ctx) DeclRefExpr(
+      partialTaskParam, DeclNameLoc(), /*Implicit=*/true,
+      AccessSemantics::Ordinary,
+      enqueuePartialTask->mapTypeIntoContext(
+        partialTaskParam->getValueInterfaceType()));
+
+  // Form the call itself.
+  auto call = CallExpr::createImplicit(
+      ctx, fnRef, { selfArg, storageVarRefExpr, partialTask },
+      { ctx.getIdentifier("actor"), ctx.getIdentifier("queue"),
+        ctx.Id_partialTask });
+  call->setType(fn->getResultInterfaceType());
+  call->setThrows(false);
 
   auto body = BraceStmt::create(
-      ctx, SourceLoc(), { }, SourceLoc(), /*implicit=*/true);
+      ctx, SourceLoc(), { call }, SourceLoc(), /*implicit=*/true);
   return { body, /*isTypeChecked=*/true };
 }
 
 /// Derive the declaration of Actor's enqueue(partialTask:).
 static ValueDecl *deriveActor_enqueuePartialTask(DerivedConformance &derived) {
   ASTContext &ctx = derived.Context;
 
+  // Retrieve the types and declarations we'll need to form this operation.
   Type partialTaskType = getPartialAsyncTaskType(ctx);
   if (!partialTaskType) {
-    derived.Nominal->diagnose(diag::partial_task_type_missing);
+    derived.Nominal->diagnose(
+        diag::concurrency_lib_missing, ctx.Id_PartialAsyncTask.str());
     return nullptr;
   }
 
   auto parentDC = derived.getConformanceContext();
+  Type defaultActorQueueType = getDefaultActorQueueType(
+      parentDC, derived.ConformanceDecl->getLoc());
+  if (!defaultActorQueueType) {
+    derived.Nominal->diagnose(
+        diag::concurrency_lib_missing, "_DefaultActorQueue");
+    return nullptr;
+  }
+
+  auto actorStorageCreateFn = getDefaultActorQueueCreate(
+      parentDC, derived.ConformanceDecl->getLoc());
+  if (!actorStorageCreateFn) {
+    derived.Nominal->diagnose(
+        diag::concurrency_lib_missing, "_defaultActorQueueCreate");
+    return nullptr;
+  }
+
+  // Partial task parameter to enqueue(partialTask:).
   auto partialTaskParamDecl = new (ctx) ParamDecl(
       SourceLoc(), SourceLoc(), ctx.Id_partialTask,
       SourceLoc(), ctx.Id_partialTask, parentDC);
   partialTaskParamDecl->setInterfaceType(partialTaskType);
   partialTaskParamDecl->setSpecifier(ParamSpecifier::Default);
 
+  // enqueue(partialTask:) method.
   ParameterList *params = ParameterList::createWithoutLoc(partialTaskParamDecl);
   auto func = FuncDecl::createImplicit(
       ctx, StaticSpellingKind::None, getEnqueuePartialTaskName(ctx),
       SourceLoc(), /*Async=*/false, /*Throws=*/false, /*GenericParams=*/nullptr,
       params, TupleType::getEmpty(ctx), parentDC);
   func->copyFormalAccessFrom(derived.Nominal);
   func->setBodySynthesizer(deriveBodyActor_enqueuePartialTask);
+  func->setSynthesized();
 
   // FIXME: This function should be "actor-unsafe", not "actor-independent", but
   // the latter is all we have at the moment.
   func->getAttrs().add(new (ctx) ActorIndependentAttr(/*IsImplicit=*/true));
 
-  derived.addMembersToConformanceContext({func});
+  // Actor storage property and its initialization.
+  auto actorStorage = new (ctx) VarDecl(
+      /*isStatic=*/false, VarDecl::Introducer::Var, SourceLoc(),
+      ctx.Id_actorStorage, parentDC);
+  actorStorage->setInterfaceType(defaultActorQueueType);
+  actorStorage->setImplicit();
+  actorStorage->setAccess(AccessLevel::Private);
+  actorStorage->getAttrs().add(new (ctx) FinalAttr(/*Implicit=*/true));
+
+  // Pattern binding to initialize the actor storage.
+  Pattern *actorStoragePattern = NamedPattern::createImplicit(
+      ctx, actorStorage);
+  actorStoragePattern = TypedPattern::createImplicit(
+      ctx, actorStoragePattern, defaultActorQueueType);
+
+  // Initialization expression.
+  // FIXME: We want the equivalent of type(of: self) here, but we cannot refer
+  // to self, so for now we use the static type instead.
+  Type nominalType = derived.Nominal->getDeclaredTypeInContext();
+  Expr *metatypeArg = TypeExpr::createImplicit(nominalType, ctx);
+  Type anyObjectMetatype = ExistentialMetatypeType::get(ctx.getAnyObjectType());
+  metatypeArg = ErasureExpr::create(ctx, metatypeArg, anyObjectMetatype, { });
+  Expr *actorStorageCreateFnRef = new (ctx) DeclRefExpr(
+      actorStorageCreateFn, DeclNameLoc(), /*Implicit=*/true);
+  actorStorageCreateFnRef->setType(actorStorageCreateFn->getInterfaceType());
+
+  auto actorStorageInit = CallExpr::createImplicit(
+      ctx, actorStorageCreateFnRef, { metatypeArg}, { Identifier() });
+  actorStorageInit->setType(actorStorageCreateFn->getResultInterfaceType());
+  actorStorageInit->setThrows(false);
+
+  auto actorStoragePatternBinding = PatternBindingDecl::createImplicit(
+      ctx, StaticSpellingKind::None, actorStoragePattern, actorStorageInit,
+      parentDC);
+  actorStoragePatternBinding->setInitializerChecked(0);
+
+  derived.addMembersToConformanceContext(
+      { func, actorStorage, actorStoragePatternBinding });
   return func;
 }
 
@@ -97,7 +287,7 @@ ValueDecl *DerivedConformance::deriveActor(ValueDecl *requirement) {
   if (!func)
     return nullptr;
 
-  if (func->getName() == getEnqueuePartialTaskName(Context))
+  if (isEnqueuePartialTask(Context, func->getName()))
     return deriveActor_enqueuePartialTask(*this);
 
   return nullptr;

lib/Sema/TypeCheckStorage.cpp

@@ -30,6 +30,7 @@
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/PropertyWrappers.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/SourceFile.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/Types.h"
@@ -113,6 +114,21 @@ static void computeLoweredStoredProperties(NominalTypeDecl *decl) {
     if (var->hasAttachedPropertyWrapper())
       (void) var->getPropertyWrapperBackingProperty();
   }
+
+  // If this is an actor class, check conformance to the Actor protocol to
+  // ensure that the actor storage will get created (if needed).
+  if (auto classDecl = dyn_cast<ClassDecl>(decl)) {
+    if (classDecl->isActor()) {
+      ASTContext &ctx = decl->getASTContext();
+      if (auto actorProto = ctx.getProtocol(KnownProtocolKind::Actor)) {
+        SmallVector<ProtocolConformance *, 1> conformances;
+        classDecl->lookupConformance(
+            decl->getModuleContext(), actorProto, conformances);
+        for (auto conformance : conformances)
+          TypeChecker::checkConformance(conformance->getRootNormalConformance());
+      }
+    }
+  }
 }
 
 ArrayRef<VarDecl *>
@@ -128,10 +144,16 @@ StoredPropertiesRequest::evaluate(Evaluator &evaluator,
   if (isa<SourceFile>(decl->getModuleScopeContext()))
     computeLoweredStoredProperties(decl);
 
+  ASTContext &ctx = decl->getASTContext();
   for (auto *member : decl->getMembers()) {
     if (auto *var = dyn_cast<VarDecl>(member))
-      if (!var->isStatic() && var->hasStorage())
-        results.push_back(var);
+      if (!var->isStatic() && var->hasStorage()) {
+        // Actor storage always goes at the beginning.
+        if (var->getName() == ctx.Id_actorStorage)
+          results.insert(results.begin(), var);
+        else
+          results.push_back(var);
+      }
   }
 
   return decl->getASTContext().AllocateCopy(results);

stdlib/public/Concurrency/Actor.swift

@@ -23,3 +23,33 @@ public protocol Actor: AnyObject {
   /// Enqueue a new partial task that will be executed in the actor's context.
   func enqueue(partialTask: PartialAsyncTask)
 }
+
+/// A native actor queue, which schedules partial tasks onto a serial queue.
+public struct _NativeActorQueue {
+  // TODO: This is just a stub for now
+}
+
+/// The default type to be used for an actor's queue when an actor does not
+/// provide its own implementation of `enqueue(partialTask:)`.
+public typealias _DefaultActorQueue = _NativeActorQueue
+
+/// Called to create a new default actor queue instance for a class of the given
+/// type.  The implementation will call this within the actor's initializer to
+/// initialize the actor queue.
+public func _defaultActorQueueCreate(
+  _ actorClass: AnyObject.Type
+) -> _DefaultActorQueue {
+  _DefaultActorQueue()
+}
+
+/// Called by the synthesized implementation of enqueue(partialTask:).
+///
+/// The implementation is provided with the address of the synthesized instance
+/// property for the actor queue, so that it need not be at a fixed offset.
+public func _defaultActorQueueEnqueuePartialTask(
+  actor: AnyObject,
+  queue: inout _DefaultActorQueue,
+  partialTask: PartialAsyncTask
+) {
+  // TODO: Implement queueing.
+}