[Concurrency] Implement global actor isolation rules.

Extend the actor isolation checking rules to account for global
actors. For example, a function annotated with a given global actor
can invoke synchronous methods from the same global actor, but not
from a different global actor or a particular actor instance.
Similarly, a method of an (instance) actor that is annotated with a
global actor attribute is not part of the (instance) actor and,
therefore, cannot operate on its actor-isolated state.

Author: DougGregor

include/swift/AST/ActorIsolation.h

@@ -24,6 +24,11 @@ class raw_ostream;
 
 namespace swift {
 class ClassDecl;
+class Type;
+
+/// Determine whether the given types are (canonically) equal, declared here
+/// to avoid having to include Types.h.
+bool areTypesEqual(Type type1, Type type2);
 
 /// Describes the actor isolation of a given declaration, which determines
 /// the actors with which it can interact.
@@ -38,19 +43,31 @@ class ActorIsolation {
     /// the actor is isolated to the instance of that actor.
     ActorInstance,
     /// The declaration can refer to actor-isolated state, but can also be
-    //// referenced from outside the actor.
+    /// referenced from outside the actor.
     ActorPrivileged,
     /// The declaration is explicitly specified to be independent of any actor,
     /// meaning that it can be used from any actor but is also unable to
     /// refer to the isolated state of any given actor.
     Independent,
+    /// The declaration is isolated to a global actor. It can refer to other
+    /// entities with the same global actor.
+    GlobalActor,
+    /// The declaration can refer to state isolated by the given global actor,
+    /// and can be used from anywhere.
+    GlobalActorPrivileged,
   };
 
 private:
   Kind kind;
-  ClassDecl *actor;
+  union {
+    ClassDecl *actor;
+    Type globalActor;
+    void *pointer;
+  };
 
   ActorIsolation(Kind kind, ClassDecl *actor) : kind(kind), actor(actor) { }
+  ActorIsolation(Kind kind, Type globalActor)
+      : kind(kind), globalActor(globalActor) { }
 
 public:
   static ActorIsolation forUnspecified() {
@@ -69,6 +86,14 @@ class ActorIsolation {
     return ActorIsolation(ActorInstance, actor);
   }
 
+  static ActorIsolation forGlobalActorPrivileged(Type globalActor) {
+    return ActorIsolation(GlobalActorPrivileged, globalActor);
+  }
+
+  static ActorIsolation forGlobalActor(Type globalActor) {
+    return ActorIsolation(GlobalActor, globalActor);
+  }
+
   Kind getKind() const { return kind; }
 
   operator Kind() const { return getKind(); }
@@ -78,6 +103,11 @@ class ActorIsolation {
     return actor;
   }
 
+  Type getGlobalActor() const {
+    assert(getKind() == GlobalActor || getKind() == GlobalActorPrivileged);
+    return globalActor;
+  }
+
   friend bool operator==(const ActorIsolation &lhs,
                          const ActorIsolation &rhs) {
     if (lhs.kind != rhs.kind)
@@ -91,6 +121,10 @@ class ActorIsolation {
     case ActorInstance:
     case ActorPrivileged:
       return lhs.actor == rhs.actor;
+
+    case GlobalActor:
+    case GlobalActorPrivileged:
+      return areTypesEqual(lhs.globalActor, rhs.globalActor);
     }
   }
 
@@ -100,7 +134,7 @@ class ActorIsolation {
   }
 
   friend llvm::hash_code hash_value(const ActorIsolation &state) {
-    return llvm::hash_combine(state.kind, state.actor);
+    return llvm::hash_combine(state.kind, state.pointer);
   }
 };
 

include/swift/AST/Decl.h

@@ -957,8 +957,10 @@ class alignas(1 << DeclAlignInBits) Decl {
   /// if any.
   ///
   /// This is the "raw" global actor attribute as written directly on the
-  /// declaration, with any inference rules applied.
-  CustomAttr *getGlobalActorAttr() const;
+  /// declaration, along with the nominal type declaration to which it refers,
+  /// without any inference rules applied.
+  Optional<std::pair<CustomAttr *, NominalTypeDecl *>>
+  getGlobalActorAttr() const;
 
   /// If an alternative module name is specified for this decl, e.g. using
   /// @_originalDefinedIn attribute, this function returns this module name.

include/swift/AST/DiagnosticsSema.def

@@ -4153,6 +4153,21 @@ ERROR(actor_isolated_self_independent_context,none,
         "actor-isolated %0 %1 can not be referenced from an "
         "'@actorIndependent' context",
         (DescriptiveDeclKind, DeclName))
+ERROR(actor_isolated_global_actor_context,none,
+      "actor-isolated %0 %1 can not be referenced from context of global "
+      "actor %2",
+      (DescriptiveDeclKind, DeclName, Type))
+ERROR(global_actor_from_instance_actor_context,none,
+      "%0 %1 isolated to global actor %2 can not be referenced from actor %3",
+      (DescriptiveDeclKind, DeclName, Type, DeclName))
+ERROR(global_actor_from_other_global_actor_context,none,
+      "%0 %1 isolated to global actor %2 can not be referenced from "
+      "different global actor %3",
+      (DescriptiveDeclKind, DeclName, Type, Type))
+ERROR(global_actor_from_independent_context,none,
+      "%0 %1 isolated to global actor %2 can not be referenced from an "
+      "'@actorIndependent' context",
+      (DescriptiveDeclKind, DeclName, Type))
 ERROR(actor_isolated_partial_apply,none,
         "actor-isolated %0 %1 can not be partially applied",
         (DescriptiveDeclKind, DeclName))
@@ -4231,6 +4246,10 @@ ERROR(global_actor_on_actor_class,none,
 ERROR(global_actor_on_local_variable,none,
       "local variable %0 cannot have a global actor", (DeclName))
 
+ERROR(actor_isolation_multiple_attr,none,
+      "%0 %1 has multiple actor-isolation attributes ('%2' and '%3')",
+      (DescriptiveDeclKind, DeclName, StringRef, StringRef))
+
 //------------------------------------------------------------------------------
 // MARK: Type Check Types
 //------------------------------------------------------------------------------

include/swift/AST/TypeCheckRequests.h

@@ -880,23 +880,26 @@ class GlobalActorInstanceRequest :
   bool isCached() const { return true; }
 };
 
+using CustomAttrNominalPair = std::pair<CustomAttr *, NominalTypeDecl *>;
+
 /// Request the custom attribute which denotes the global actor for the given
 /// declaration.
 ///
 /// This is the "raw" global actor attribute as written directly on the
 /// declaration, with any inference rules applied.
 class GlobalActorAttributeRequest :
-    public SimpleRequest<GlobalActorAttributeRequest,
-                         CustomAttr *(Decl *),
-                         RequestFlags::Cached> {
+    public SimpleRequest<
+        GlobalActorAttributeRequest,
+        Optional<CustomAttrNominalPair>(Decl *),
+        RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
   // Evaluation.
-  CustomAttr *
+  Optional<std::pair<CustomAttr *, NominalTypeDecl *>>
   evaluate(Evaluator &evaluator, Decl *decl) const;
 
 public:

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -91,7 +91,8 @@ SWIFT_REQUEST(TypeChecker, GlobalActorInstanceRequest,
               VarDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GlobalActorAttributeRequest,
-              CustomAttr *(Decl *), Cached, NoLocationInfo)
+              Optional<CustomAttrNominalPair>(Decl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ActorIsolationRequest,
               ActorIsolationState(ValueDecl *),
               Cached, NoLocationInfo)

include/swift/Basic/CTypeIDZone.def

@@ -38,7 +38,9 @@ SWIFT_TYPEID_NAMED(std::string, String)
 SWIFT_TYPEID_NAMED(evaluator::SideEffect, SideEffect)
 SWIFT_TYPEID_TEMPLATE1_NAMED(std::vector, Vector, typename T, T)
 SWIFT_TYPEID_TEMPLATE1_NAMED(std::unique_ptr, UniquePtr, typename T, T)
+SWIFT_TYPEID_TEMPLATE2_NAMED(std::pair, Pair, typename T1, T1, typename T2, T2)
 
 // LLVM ADT types.
 SWIFT_TYPEID_TEMPLATE1_NAMED(llvm::TinyPtrVector, TinyPtrVector, typename T, T)
 SWIFT_TYPEID_TEMPLATE1_NAMED(llvm::ArrayRef, ArrayRef, typename T, T)
+SWIFT_TYPEID_TEMPLATE1_NAMED(llvm::Optional, Optional, typename T, T)

include/swift/Basic/DefineTypeIDZone.h

@@ -40,9 +40,11 @@ template<> struct TypeIDZoneTypes<Zone::SWIFT_TYPEID_ZONE> {
   enum Types : uint8_t {
 #define SWIFT_TYPEID_NAMED(Type, Name) Name,
 #define SWIFT_TYPEID_TEMPLATE1_NAMED(Template, Name, Param1, Arg1) Name,
+#define SWIFT_TYPEID_TEMPLATE2_NAMED(Template, Name, Param1, Arg1, Param2, Arg2) Name,
 #include SWIFT_TYPEID_HEADER
 #undef SWIFT_TYPEID_NAMED
 #undef SWIFT_TYPEID_TEMPLATE1_NAMED
+#undef SWIFT_TYPEID_TEMPLATE2_NAMED
   };
 };
 
@@ -77,12 +79,34 @@ public:                                                               \
                                                                       \
 template<Param1> const uint64_t TypeID<Template<Arg1>>::value;
 
+#define SWIFT_TYPEID_TEMPLATE2_NAMED(Template, Name, Param1, Arg1, Param2, Arg2) \
+template<Param1, Param2> struct TypeID<Template<Arg1, Arg2>> {        \
+private:                                                              \
+  static const uint64_t templateID =                                  \
+    formTypeID(static_cast<uint8_t>(Zone::SWIFT_TYPEID_ZONE),         \
+               TypeIDZoneTypes<Zone::SWIFT_TYPEID_ZONE>::Name);       \
+                                                                      \
+public:                                                               \
+  static const uint64_t value =                                       \
+    (TypeID<Arg1>::value << 32) |                                     \
+    (TypeID<Arg2>::value << 16) |                                     \
+    templateID;                                                       \
+                                                                      \
+  static std::string getName() {                                      \
+    return std::string(#Name) + "<" + TypeID<Arg1>::getName() +       \
+        ", " + TypeID<Arg2>::getName() + ">";                         \
+  }                                                                   \
+};                                                                    \
+                                                                      \
+template<Param1, Param2> const uint64_t TypeID<Template<Arg1, Arg2>>::value;
+
 #include SWIFT_TYPEID_HEADER
 
 #undef SWIFT_REQUEST
 
 #undef SWIFT_TYPEID_NAMED
 #undef SWIFT_TYPEID_TEMPLATE1_NAMED
+#undef SWIFT_TYPEID_TEMPLATE2_NAMED
 
 #undef SWIFT_TYPEID
 #undef SWIFT_TYPEID_ZONE

include/swift/Basic/SimpleDisplay.h

@@ -23,6 +23,7 @@
 #include "llvm/Support/raw_ostream.h"
 #include <tuple>
 #include <type_traits>
+#include <utility>
 
 namespace swift {
   template<typename T>
@@ -93,7 +94,17 @@ namespace swift {
                       const std::tuple<Types...> &value) {
     simple_display_tuple<0>(out, value);
   }
-  
+
+  template<typename T1, typename T2>
+  void simple_display(llvm::raw_ostream &out,
+                      const std::pair<T1, T2> &value) {
+    out << "(";
+    simple_display(out, value.first);
+    out << ", ";
+    simple_display(out, value.second);
+    out << ")";
+  }
+
   template<typename T>
   void simple_display(llvm::raw_ostream &out,
                       const llvm::TinyPtrVector<T> &vector) {

lib/AST/Decl.cpp

@@ -672,12 +672,12 @@ static_assert(sizeof(checkSourceLocType(&ID##Decl::getLoc)) == 2, \
   llvm_unreachable("invalid file kind");
 }
 
-CustomAttr *Decl::getGlobalActorAttr() const {
+Optional<CustomAttrNominalPair> Decl::getGlobalActorAttr() const {
   auto &ctx = getASTContext();
   auto mutableThis = const_cast<Decl *>(this);
   return evaluateOrDefault(ctx.evaluator,
                            GlobalActorAttributeRequest{mutableThis},
-                           nullptr);
+                           None);
 }
 
 Expr *AbstractFunctionDecl::getSingleExpressionBody() const {

lib/AST/TypeCheckRequests.cpp

@@ -1466,9 +1466,26 @@ void swift::simple_display(
     case ActorIsolation::Unspecified:
       out << "unspecified actor isolation";
       break;
+
+    case ActorIsolation::GlobalActor:
+      out << "actor-isolated to global actor "
+          << state.getGlobalActor().getString();
+      break;
+
+    case ActorIsolation::GlobalActorPrivileged:
+      out << "actor-privileged to global actor "
+          << state.getGlobalActor().getString();
+      break;
   }
 }
 
+bool swift::areTypesEqual(Type type1, Type type2) {
+  if (!type1 || !type2)
+    return !type1 && !type2;
+
+  return type1->isEqual(type2);
+}
+
 void swift::simple_display(
     llvm::raw_ostream &out, BodyInitKind initKind) {
   switch (initKind) {