Declarations within Actor-conforming protocols are actor-isolated.

The Actor protocol is used only to describe actors. When a protocol's
Self type conforms to the actor protocol, any instance declarations on
the protocol or extensions thereof are considered to be actor-isolated
to 'self'.

Because the instance requirements of such a protocol are
actor-isolated to 'self', they can be witnessed by actor-isolated
instance declarations on an actor type. For example:

```swift
protocol P: Actor {
  func f() // okay, actor-isolated to self
}

extension P {
  func g() { f() } // okay, actor-islated to self
}

actor MyActor: P {
  func f() { } // okay, witnesses actor-isolated requirement
}
```

Author: DougGregor

include/swift/AST/ActorIsolation.h

@@ -65,12 +65,14 @@ class ActorIsolation {
 private:
   Kind kind;
   union {
-    ClassDecl *actor;
+    NominalTypeDecl *actor;
     Type globalActor;
     void *pointer;
   };
 
-  ActorIsolation(Kind kind, ClassDecl *actor) : kind(kind), actor(actor) { }
+  ActorIsolation(Kind kind, NominalTypeDecl *actor)
+      : kind(kind), actor(actor) { }
+
   ActorIsolation(Kind kind, Type globalActor)
       : kind(kind), globalActor(globalActor) { }
 
@@ -93,7 +95,7 @@ class ActorIsolation {
     return ActorIsolation(isoKind, nullptr);
   }
 
-  static ActorIsolation forActorInstance(ClassDecl *actor) {
+  static ActorIsolation forActorInstance(NominalTypeDecl *actor) {
     return ActorIsolation(ActorInstance, actor);
   }
 
@@ -108,7 +110,7 @@ class ActorIsolation {
 
   bool isUnspecified() const { return kind == Unspecified; }
 
-  ClassDecl *getActor() const {
+  NominalTypeDecl *getActor() const {
     assert(getKind() == ActorInstance);
     return actor;
   }

include/swift/AST/Decl.h

@@ -3159,6 +3159,11 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// with placeholders for unimportable stored properties.
   ArrayRef<Decl *> getStoredPropertiesAndMissingMemberPlaceholders() const;
 
+  /// Whether this nominal type qualifies as an actor, meaning that it is
+  /// either an actor type or a protocol whose `Self` type conforms to the
+  /// `Actor` protocol.
+  bool isActor() const;
+
   /// Return the range of semantics attributes attached to this NominalTypeDecl.
   auto getSemanticsAttrs() const
       -> decltype(getAttrs().getSemanticsAttrs()) {
@@ -3699,9 +3704,6 @@ class ClassDecl final : public NominalTypeDecl {
     return getForeignClassKind() != ForeignKind::Normal;
   }
 
-  /// Whether the class is an actor.
-  bool isActor() const;
-
   /// Whether the class is (known to be) a default actor.
   bool isDefaultActor() const;
 

include/swift/AST/TypeCheckRequests.h

@@ -917,18 +917,18 @@ class CanBeAsyncHandlerRequest :
   bool isCached() const { return true; }
 };
 
-/// Determine whether the given class is an actor.
+/// Determine whether the given nominal type is an actor.
 class IsActorRequest :
     public SimpleRequest<IsActorRequest,
-                         bool(ClassDecl *),
+                         bool(NominalTypeDecl *),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  bool evaluate(Evaluator &evaluator, ClassDecl *classDecl) const;
+  bool evaluate(Evaluator &evaluator, NominalTypeDecl *nominal) const;
 
 public:
   // Caching

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -94,7 +94,7 @@ SWIFT_REQUEST(TypeChecker, IsAsyncHandlerRequest, bool(FuncDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, CanBeAsyncHandlerRequest, bool(FuncDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, IsActorRequest, bool(ClassDecl *),
+SWIFT_REQUEST(TypeChecker, IsActorRequest, bool(NominalTypeDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsDefaultActorRequest, bool(ClassDecl *),
               Cached, NoLocationInfo)

include/swift/AST/Types.h

@@ -731,6 +731,9 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// Break an existential down into a set of constraints.
   ExistentialLayout getExistentialLayout();
 
+  /// Determines whether this type is an actor type.
+  bool isActorType();
+
   /// Determines the element type of a known
   /// [Autoreleasing]Unsafe[Mutable][Raw]Pointer variant, or returns null if the
   /// type is not a pointer.

lib/AST/Decl.cpp

@@ -3763,6 +3763,14 @@ PropertyWrapperTypeInfo NominalTypeDecl::getPropertyWrapperTypeInfo() const {
                            PropertyWrapperTypeInfo());
 }
 
+bool NominalTypeDecl::isActor() const {
+  auto mutableThis = const_cast<NominalTypeDecl *>(this);
+  return evaluateOrDefault(getASTContext().evaluator,
+                           IsActorRequest{mutableThis},
+                           false);
+}
+
+
 GenericTypeDecl::GenericTypeDecl(DeclKind K, DeclContext *DC,
                                  Identifier name, SourceLoc nameLoc,
                                  ArrayRef<TypeLoc> inherited,
@@ -4203,13 +4211,6 @@ GetDestructorRequest::evaluate(Evaluator &evaluator, ClassDecl *CD) const {
   return DD;
 }
 
-bool ClassDecl::isActor() const {
-  auto mutableThis = const_cast<ClassDecl *>(this);
-  return evaluateOrDefault(getASTContext().evaluator,
-                           IsActorRequest{mutableThis},
-                           false);
-}
-
 bool ClassDecl::isDefaultActor() const {
   auto mutableThis = const_cast<ClassDecl *>(this);
   return evaluateOrDefault(getASTContext().evaluator,

lib/AST/Type.cpp

@@ -358,6 +358,46 @@ bool CanType::isTypeErasedGenericClassTypeImpl(CanType type) {
   return false;
 }
 
+bool TypeBase::isActorType() {
+  // Nominal types: check whether the declaration is an actor.
+  if (auto nominal = getAnyNominal())
+    return nominal->isActor();
+
+  // Archetypes check for conformance to Actor.
+  if (auto archetype = getAs<ArchetypeType>()) {
+    auto actorProto = getASTContext().getProtocol(KnownProtocolKind::Actor);
+    if (!actorProto)
+      return false;
+
+    auto interfaceType = archetype->getInterfaceType();
+    auto genericEnv = archetype->getGenericEnvironment();
+    return genericEnv->getGenericSignature()->requiresProtocol(
+        interfaceType, actorProto);
+  }
+
+  // Existential types: check for Actor protocol.
+  if (isExistentialType()) {
+    auto actorProto = getASTContext().getProtocol(KnownProtocolKind::Actor);
+    if (!actorProto)
+      return false;
+
+    auto layout = getExistentialLayout();
+    if (auto superclass = layout.getSuperclass()) {
+      if (superclass->isActorType())
+        return true;
+    }
+
+    for (auto proto : layout.getProtocols()) {
+      if (proto->isActorType())
+        return true;
+    }
+
+    return false;
+  }
+
+  return false;
+}
+
 bool TypeBase::isSpecialized() {
   Type t = getCanonicalType();
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -236,7 +236,31 @@ bool CanBeAsyncHandlerRequest::evaluate(
 }
 
 bool IsActorRequest::evaluate(
-    Evaluator &evaluator, ClassDecl *classDecl) const {
+    Evaluator &evaluator, NominalTypeDecl *nominal) const {
+  // Protocols are actors if their `Self` type conforms to `Actor`.
+  if (auto protocol = dyn_cast<ProtocolDecl>(nominal)) {
+    // Simple case: we have the Actor protocol itself.
+    if (protocol->isSpecificProtocol(KnownProtocolKind::Actor))
+      return true;
+
+    auto actorProto = nominal->getASTContext().getProtocol(
+        KnownProtocolKind::Actor);
+    if (!actorProto)
+      return false;
+
+    auto selfType = Type(protocol->getProtocolSelfType());
+    auto genericSig = protocol->getGenericSignature();
+    if (!genericSig)
+      return false;
+
+    return genericSig->requiresProtocol(selfType, actorProto);
+  }
+
+  // Class declarations are actors if they were declared with "actor".
+  auto classDecl = dyn_cast<ClassDecl>(nominal);
+  if (!classDecl)
+    return false;
+
   bool isExplicitActor = classDecl->isExplicitActor() ||
     classDecl->getAttrs().getAttribute<ActorAttr>();
 
@@ -1362,12 +1386,14 @@ namespace {
     }
 
     // Retrieve the nearest enclosing actor context.
-    static ClassDecl *getNearestEnclosingActorContext(const DeclContext *dc) {
+    static NominalTypeDecl *getNearestEnclosingActorContext(
+        const DeclContext *dc) {
       while (!dc->isModuleScopeContext()) {
         if (dc->isTypeContext()) {
-          if (auto classDecl = dc->getSelfClassDecl()) {
-            if (classDecl->isActor())
-              return classDecl;
+          // FIXME: Protocol extensions need specific handling here.
+          if (auto nominal = dc->getSelfNominalTypeDecl()) {
+            if (nominal->isActor())
+              return nominal;
           }
         }
 
@@ -1962,7 +1988,7 @@ namespace {
               memberLoc, diag::actor_isolated_non_self_reference,
               member->getDescriptiveKind(),
               member->getName(),
-              isolation.getActorClass() ==
+              isolation.getActorType() ==
                 getNearestEnclosingActorContext(getDeclContext()),
               useKind
               );
@@ -2326,9 +2352,18 @@ static Optional<ActorIsolation> getIsolationFromWitnessedRequirements(
         continue;
 
       auto requirementIsolation = getActorIsolation(requirement);
-      if (requirementIsolation.isUnspecified())
+      switch (requirementIsolation) {
+      case ActorIsolation::ActorInstance:
+      case ActorIsolation::Unspecified:
         continue;
 
+      case ActorIsolation::GlobalActor:
+      case ActorIsolation::GlobalActorUnsafe:
+      case ActorIsolation::Independent:
+      case ActorIsolation::IndependentUnsafe:
+        break;
+      }
+
       auto witness = conformance->getWitnessDecl(requirement);
       if (witness != value)
         continue;
@@ -2417,12 +2452,13 @@ ActorIsolation ActorIsolationRequest::evaluate(
     }
   }
 
-  // Check for instance members and initializers of actor classes,
+  // Check for instance members and initializers of actor types,
   // which are part of actor-isolated state.
-  auto classDecl = value->getDeclContext()->getSelfClassDecl();
-  if (classDecl && classDecl->isActor() &&
-      (value->isInstanceMember() || isa<ConstructorDecl>(value))) {
-    defaultIsolation = ActorIsolation::forActorInstance(classDecl);
+  if (auto nominal = value->getDeclContext()->getSelfNominalTypeDecl()) {
+    if (nominal->isActor() &&
+        (value->isInstanceMember() || isa<ConstructorDecl>(value))) {
+      defaultIsolation = ActorIsolation::forActorInstance(nominal);
+    }
   }
 
   // Function used when returning an inferred isolation.

lib/Sema/TypeCheckConcurrency.h

@@ -103,8 +103,8 @@ class ActorIsolationRestriction {
     /// The local context that an entity is tied to.
     DeclContext *localContext;
 
-    /// The actor class that the entity is declared in.
-    ClassDecl *actorClass;
+    /// The actor that the entity is declared in.
+    NominalTypeDecl *actorType;
 
     /// The global actor type.
     TypeBase *globalActor;
@@ -123,10 +123,10 @@ class ActorIsolationRestriction {
 
   Kind getKind() const { return kind; }
 
-  /// Retrieve the actor class that the declaration is within.
-  ClassDecl *getActorClass() const {
+  /// Retrieve the actor type that the declaration is within.
+  NominalTypeDecl *getActorType() const {
     assert(kind == ActorSelf || kind == CrossActorSelf);
-    return data.actorClass;
+    return data.actorType;
   }
 
   /// Retrieve the actor class that the declaration is within.
@@ -148,10 +148,10 @@ class ActorIsolationRestriction {
   /// Accesses to the given declaration can only be made via the 'self' of
   /// the current actor or is a cross-actor access.
   static ActorIsolationRestriction forActorSelf(
-      ClassDecl *actorClass, bool isCrossActor) {
+      NominalTypeDecl *actor, bool isCrossActor) {
     ActorIsolationRestriction result(isCrossActor? CrossActorSelf : ActorSelf,
                                      isCrossActor);
-    result.data.actorClass = actorClass;
+    result.data.actorType = actor;
     return result;
   }
 

lib/Sema/TypeCheckProtocol.cpp

@@ -2729,7 +2729,11 @@ bool ConformanceChecker::checkActorIsolation(
   switch (auto witnessRestriction =
               ActorIsolationRestriction::forDeclaration(witness)) {
   case ActorIsolationRestriction::ActorSelf: {
-    // Actor-isolated witnesses cannot conform to protocol requirements.
+    // An actor-isolated witness can only conform to an actor-isolated
+    // requirement.
+    if (getActorIsolation(requirement) == ActorIsolation::ActorInstance)
+      return false;
+
     witness->diagnose(diag::actor_isolated_witness,
                       witness->getDescriptiveKind(),
                       witness->getName());