Collapse ActorIsolationRestriction::CrossGlobalActor into GlobalActor.

Whether it's a cross-actor reference is better modeled as a separate
axis rather than part of the "kind". All of the clients were treating it
this was already.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -1297,7 +1297,6 @@ namespace {
         case ActorIsolationRestriction::Unrestricted:
         case ActorIsolationRestriction::Unsafe:
           break;
-        case ActorIsolationRestriction::CrossGlobalActor:
         case ActorIsolationRestriction::GlobalActor: {
           ctx.Diags.diagnose(argLoc, diag::actor_isolated_inout_state,
                              decl->getDescriptiveKind(), decl->getName(),
@@ -1683,11 +1682,9 @@ namespace {
       case ActorIsolationRestriction::ActorSelf:
         llvm_unreachable("non-member reference into an actor");
 
-      case ActorIsolationRestriction::CrossGlobalActor:
       case ActorIsolationRestriction::GlobalActor:
         return checkGlobalActorReference(
-            valueRef, loc, isolation.getGlobalActor(),
-            isolation == ActorIsolationRestriction::CrossGlobalActor);
+            valueRef, loc, isolation.getGlobalActor(), isolation.isCrossActor);
 
       case ActorIsolationRestriction::Unsafe:
         return diagnoseReferenceToUnsafeGlobal(value, loc);
@@ -1855,11 +1852,10 @@ namespace {
         llvm_unreachable("Unhandled actor isolation");
       }
 
-      case ActorIsolationRestriction::CrossGlobalActor:
       case ActorIsolationRestriction::GlobalActor:
         return checkGlobalActorReference(
             memberRef, memberLoc, isolation.getGlobalActor(),
-            isolation == ActorIsolationRestriction::CrossGlobalActor);
+            isolation.isCrossActor);
 
       case ActorIsolationRestriction::Unsafe:
         // This case is hit when passing actor state inout to functions in some

lib/Sema/TypeCheckConcurrency.h

@@ -86,19 +86,13 @@ class ActorIsolationRestriction {
     /// the actor's isolation domain.
     ActorSelf,
 
-    /// References to a declaration that is part of a global actor are only
-    /// permitted from other declarations with that same global actor.
+    /// References to a declaration that is part of a global actor are
+    /// permitted from other declarations with that same global actor or
+    /// are permitted from elsewhere as a cross-actor reference.
     GlobalActor,
-
-    /// References to this entity are allowed from anywhere, but doing so may
-    /// cross an actor boundary if it is not from the same global actor.
-    CrossGlobalActor,
   };
 
 private:
-  /// The kind of restriction.
-  Kind kind;
-
   union {
     /// The local context that an entity is tied to.
     DeclContext *localContext;
@@ -110,9 +104,17 @@ class ActorIsolationRestriction {
     TypeBase *globalActor;
   } data;
 
-  explicit ActorIsolationRestriction(Kind kind) : kind(kind) { }
+  explicit ActorIsolationRestriction(Kind kind, bool isCrossActor)
+      : kind(kind), isCrossActor(isCrossActor) { }
 
 public:
+  /// The kind of restriction.
+  const Kind kind;
+
+  /// Whether referencing this from another actor constitutes a cross-acter
+  /// reference.
+  const bool isCrossActor;
+
   Kind getKind() const { return kind; }
 
   /// Retrieve the actor class that the declaration is within.
@@ -123,25 +125,26 @@ class ActorIsolationRestriction {
 
   /// Retrieve the actor class that the declaration is within.
   Type getGlobalActor() const {
-    assert(kind == GlobalActor || kind == CrossGlobalActor);
+    assert(kind == GlobalActor);
     return Type(data.globalActor);
   }
 
   /// There are no restrictions on the use of the entity.
   static ActorIsolationRestriction forUnrestricted() {
-    return ActorIsolationRestriction(Unrestricted);
+    return ActorIsolationRestriction(Unrestricted, /*isCrossActor=*/false);
   }
 
   /// Accesses to the given declaration are unsafe.
   static ActorIsolationRestriction forUnsafe() {
-    return ActorIsolationRestriction(Unsafe);
+    return ActorIsolationRestriction(Unsafe, /*isCrossActor=*/false);
   }
 
   /// 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) {
-    ActorIsolationRestriction result(isCrossActor? CrossActorSelf : ActorSelf);
+    ActorIsolationRestriction result(isCrossActor? CrossActorSelf : ActorSelf,
+                                     isCrossActor);
     result.data.actorClass = actorClass;
     return result;
   }
@@ -150,8 +153,7 @@ class ActorIsolationRestriction {
   /// global actor or is a cross-actor access.
   static ActorIsolationRestriction forGlobalActor(
       Type globalActor, bool isCrossActor) {
-    ActorIsolationRestriction result(
-        isCrossActor ? CrossGlobalActor : GlobalActor);
+    ActorIsolationRestriction result(GlobalActor, isCrossActor);
     result.data.globalActor = globalActor.getPointer();
     return result;
   }

lib/Sema/TypeCheckDeclObjC.cpp

@@ -408,7 +408,6 @@ static bool checkObjCActorIsolation(const ValueDecl *VD,
     }
     return true;
 
-  case ActorIsolationRestriction::CrossGlobalActor:
   case ActorIsolationRestriction::GlobalActor:
     // FIXME: Consider whether to limit @objc on global-actor-qualified
     // declarations.

lib/Sema/TypeCheckProtocol.cpp

@@ -2762,13 +2762,10 @@ bool ConformanceChecker::checkActorIsolation(
     return diagnoseNonConcurrentTypesInReference(
         witness, DC, witness->getLoc(), ConcurrentReferenceKind::CrossActor);
 
-  case ActorIsolationRestriction::CrossGlobalActor:
-    isCrossActor = true;
-    LLVM_FALLTHROUGH;
-
   case ActorIsolationRestriction::GlobalActor: {
     // Hang on to the global actor that's used for the witness. It will need
     // to match that of the requirement.
+    isCrossActor = witnessRestriction.isCrossActor;
     witnessGlobalActor = witness->getDeclContext()->mapTypeIntoContext(
         witnessRestriction.getGlobalActor());
     break;