[Concurrency] Introduce Actor protocol to which actor classes all conform.

Introduce a new Actor protocol, which is a class-bound protocol with only
one requirement:

    func enqueue(partialTask: PartialAsyncTask)

All actor classes implicitly conform to this protocol, and will synthesize
a (currently empty) definition of `enqueue(partialTask:)` unless a suitable
one is provided explicitly.

Author: DougGregor

include/swift/AST/Decl.h

@@ -4175,6 +4175,7 @@ enum class KnownDerivableProtocolKind : uint8_t {
   Decodable,
   AdditiveArithmetic,
   Differentiable,
+  Actor,
 };
 
 /// ProtocolDecl - A declaration of a protocol, for example:

include/swift/AST/DiagnosticsSema.def

@@ -4195,6 +4195,13 @@ 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(enqueue_partial_task_not_in_context,none,
+      "'enqueue(partialTask:)' can only be implemented in the definition of "
+      "actor class %0", (Type))
+
 //------------------------------------------------------------------------------
 // MARK: Type Check Types
 //------------------------------------------------------------------------------

include/swift/AST/KnownIdentifiers.def

@@ -44,6 +44,7 @@ IDENTIFIER(Change)
 IDENTIFIER_WITH_NAME(code_, "_code")
 IDENTIFIER(CodingKeys)
 IDENTIFIER(combine)
+IDENTIFIER_(Concurrency)
 IDENTIFIER(container)
 IDENTIFIER(CoreGraphics)
 IDENTIFIER(CoreMedia)
@@ -67,6 +68,7 @@ IDENTIFIER(encode)
 IDENTIFIER(encodeIfPresent)
 IDENTIFIER(Encoder)
 IDENTIFIER(encoder)
+IDENTIFIER(enqueue)
 IDENTIFIER(erasing)
 IDENTIFIER(error)
 IDENTIFIER(errorDomain)
@@ -105,6 +107,8 @@ IDENTIFIER(oldValue)
 IDENTIFIER(Optional)
 IDENTIFIER_(OptionalNilComparisonType)
 IDENTIFIER(parameter)
+IDENTIFIER(partialTask)
+IDENTIFIER(PartialAsyncTask)
 IDENTIFIER(projected)
 IDENTIFIER(projectedValue)
 IDENTIFIER(Protocol)

include/swift/AST/KnownProtocols.def

@@ -58,6 +58,7 @@
 #define BUILTIN_EXPRESSIBLE_BY_LITERAL_PROTOCOL_(name) \
     BUILTIN_EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME(name, "_" #name)
 
+PROTOCOL(Actor)
 PROTOCOL(Sequence)
 PROTOCOL(IteratorProtocol)
 PROTOCOL(RawRepresentable)

lib/AST/ASTContext.cpp

@@ -947,6 +947,9 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   case KnownProtocolKind::Differentiable:
     M = getLoadedModule(Id_Differentiation);
     break;
+  case KnownProtocolKind::Actor:
+    M = getLoadedModule(Id_Concurrency);
+    break;
   default:
     M = getStdlibModule();
     break;

lib/AST/Decl.cpp

@@ -5047,7 +5047,8 @@ void ProtocolDecl::computeKnownProtocolKind() const {
   auto module = getModuleContext();
   if (module != module->getASTContext().getStdlibModule() &&
       !module->getName().is("Foundation") &&
-      !module->getName().is("_Differentiation")) {
+      !module->getName().is("_Differentiation") &&
+      !module->getName().is("_Concurrency")) {
     const_cast<ProtocolDecl *>(this)->Bits.ProtocolDecl.KnownProtocol = 1;
     return;
   }
@@ -5093,6 +5094,8 @@ Optional<KnownDerivableProtocolKind>
     return KnownDerivableProtocolKind::AdditiveArithmetic;
   case KnownProtocolKind::Differentiable:
     return KnownDerivableProtocolKind::Differentiable;
+  case KnownProtocolKind::Actor:
+    return KnownDerivableProtocolKind::Actor;
   default: return None;
   }
 }

lib/AST/ProtocolConformance.cpp

@@ -1256,6 +1256,12 @@ void NominalTypeDecl::prepareConformanceTable() const {
       addSynthesized(KnownProtocolKind::RawRepresentable);
     }
   }
+
+  // Actor classes conform to the actor protocol.
+  if (auto classDecl = dyn_cast<ClassDecl>(mutableThis)) {
+    if (classDecl->isActor())
+      addSynthesized(KnownProtocolKind::Actor);
+  }
 }
 
 bool NominalTypeDecl::lookupConformance(

lib/IRGen/GenMeta.cpp

@@ -5045,6 +5045,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::AdditiveArithmetic:
   case KnownProtocolKind::Differentiable:
   case KnownProtocolKind::FloatingPoint:
+  case KnownProtocolKind::Actor:
     return SpecialProtocol::None;
   }
 

lib/Sema/CMakeLists.txt

@@ -17,6 +17,7 @@ add_swift_host_library(swiftSema STATIC
   ConstraintLocator.cpp
   ConstraintSystem.cpp
   DebuggerTestingTransform.cpp
+  DerivedConformanceActor.cpp
   DerivedConformanceAdditiveArithmetic.cpp
   DerivedConformanceCaseIterable.cpp
   DerivedConformanceCodable.cpp

lib/Sema/DerivedConformanceActor.cpp

@@ -0,0 +1,104 @@
+//===--- DerivedConformanceEquatableHashable.cpp - Derived Equatable & co -===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements implicit derivation of the Actor protocol.
+//
+//===----------------------------------------------------------------------===//
+#include "DerivedConformances.h"
+#include "TypeChecker.h"
+#include "swift/AST/ParameterList.h"
+
+using namespace swift;
+
+bool DerivedConformance::canDeriveActor(
+    NominalTypeDecl *nominal, DeclContext *dc) {
+  auto classDecl = dyn_cast<ClassDecl>(nominal);
+  return classDecl && classDecl->isActor() && dc == nominal;
+}
+
+static DeclName getEnqueuePartialTaskName(ASTContext &ctx) {
+  return DeclName(ctx, ctx.Id_enqueue, { ctx.Id_partialTask });
+}
+
+static Type getPartialAsyncTaskType(ASTContext &ctx) {
+  auto concurrencyModule = ctx.getLoadedModule(ctx.Id_Concurrency);
+  if (!concurrencyModule)
+    return Type();
+
+  SmallVector<ValueDecl *, 2> decls;
+  concurrencyModule->lookupQualified(
+      concurrencyModule, DeclNameRef(ctx.Id_PartialAsyncTask),
+      NL_QualifiedDefault, decls);
+  for (auto decl : decls) {
+    if (auto typeDecl = dyn_cast<TypeDecl>(decl))
+      return typeDecl->getDeclaredInterfaceType();
+  }
+
+  return Type();
+}
+
+static std::pair<BraceStmt *, bool>
+deriveBodyActor_enqueuePartialTask(
+  AbstractFunctionDecl *enqueuePartialTask, void *) {
+  ASTContext &ctx = enqueuePartialTask->getASTContext();
+
+  // FIXME: Call into runtime API to enqueue the task, once we figure out
+  // what that runtime API should look like.
+
+  auto body = BraceStmt::create(
+      ctx, SourceLoc(), { }, 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;
+
+  Type partialTaskType = getPartialAsyncTaskType(ctx);
+  if (!partialTaskType) {
+    derived.Nominal->diagnose(diag::partial_task_type_missing);
+    return nullptr;
+  }
+
+  auto parentDC = derived.getConformanceContext();
+  auto partialTaskParamDecl = new (ctx) ParamDecl(
+      SourceLoc(), SourceLoc(), ctx.Id_partialTask,
+      SourceLoc(), ctx.Id_partialTask, parentDC);
+  partialTaskParamDecl->setInterfaceType(partialTaskType);
+  partialTaskParamDecl->setSpecifier(ParamSpecifier::Default);
+
+  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);
+
+  // 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});
+  return func;
+}
+
+ValueDecl *DerivedConformance::deriveActor(ValueDecl *requirement) {
+  auto func = dyn_cast<FuncDecl>(requirement);
+  if (!func)
+    return nullptr;
+
+  if (func->getName() == getEnqueuePartialTaskName(Context))
+    return deriveActor_enqueuePartialTask(*this);
+
+  return nullptr;
+}