Remove ActorIsolation::DistributedActorInstance.

include/swift/AST/ActorIsolation.h

@@ -55,10 +55,6 @@ class ActorIsolation {
     /// For example, a mutable stored property or synchronous function within
     /// the actor is isolated to the instance of that actor.
     ActorInstance,
-    /// The declaration is isolated to a (potentially) distributed actor.
-    /// Distributed actors may access _their_ state (same as 'ActorInstance')
-    /// however others may not access any properties on other distributed actors.
-    DistributedActorInstance,
     /// 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.
@@ -99,10 +95,6 @@ class ActorIsolation {
     return ActorIsolation(ActorInstance, actor);
   }
 
-  static ActorIsolation forDistributedActorInstance(NominalTypeDecl *actor) {
-    return ActorIsolation(DistributedActorInstance, actor);
-  }
-
   static ActorIsolation forGlobalActor(Type globalActor, bool unsafe) {
     return ActorIsolation(
         unsafe ? GlobalActorUnsafe : GlobalActor, globalActor);
@@ -117,7 +109,7 @@ class ActorIsolation {
   bool isIndependent() const { return kind == Independent; }
 
   NominalTypeDecl *getActor() const {
-    assert(getKind() == ActorInstance || getKind() == DistributedActorInstance);
+    assert(getKind() == ActorInstance);
     return actor;
   }
 
@@ -151,7 +143,6 @@ class ActorIsolation {
       return true;
 
     case ActorInstance:
-    case DistributedActorInstance:
       return lhs.actor == rhs.actor;
 
     case GlobalActor:

lib/AST/Decl.cpp

@@ -2013,14 +2013,13 @@ static bool deferMatchesEnclosingAccess(const FuncDecl *defer) {
           return true;
 
         switch (getActorIsolation(type)) {
-          case swift::ActorIsolation::Unspecified:
-          case swift::ActorIsolation::GlobalActorUnsafe:
+          case ActorIsolation::Unspecified:
+          case ActorIsolation::GlobalActorUnsafe:
             break;
 
-          case swift::ActorIsolation::ActorInstance:
-          case swift::ActorIsolation::DistributedActorInstance:
-          case swift::ActorIsolation::Independent:
-          case swift::ActorIsolation::GlobalActor:
+          case ActorIsolation::ActorInstance:
+          case ActorIsolation::Independent:
+          case ActorIsolation::GlobalActor:
             return true;
         }
       }

lib/AST/DiagnosticEngine.cpp

@@ -832,10 +832,6 @@ static void formatDiagnosticArgument(StringRef Modifier,
       Out << "actor-isolated";
       break;
 
-    case ActorIsolation::DistributedActorInstance:
-      Out << "distributed actor-isolated";
-      break;
-
     case ActorIsolation::GlobalActor:
     case ActorIsolation::GlobalActorUnsafe: {
       Type globalActor = isolation.getGlobalActor();

lib/AST/TypeCheckRequests.cpp

@@ -1488,7 +1488,6 @@ void CustomAttrTypeRequest::cacheResult(Type value) const {
 bool ActorIsolation::requiresSubstitution() const {
   switch (kind) {
   case ActorInstance:
-  case DistributedActorInstance:
   case Independent:
   case Unspecified:
     return false;
@@ -1503,7 +1502,6 @@ bool ActorIsolation::requiresSubstitution() const {
 ActorIsolation ActorIsolation::subst(SubstitutionMap subs) const {
   switch (kind) {
   case ActorInstance:
-  case DistributedActorInstance:
   case Independent:
   case Unspecified:
     return *this;
@@ -1523,10 +1521,6 @@ void swift::simple_display(
       out << "actor-isolated to instance of " << state.getActor()->getName();
       break;
 
-    case ActorIsolation::DistributedActorInstance:
-      out << "distributed-actor-isolated to instance of " << state.getActor()->getName();
-      break;
-
     case ActorIsolation::Independent:
       out << "actor-independent";
       break;

lib/IDE/CodeCompletion.cpp

@@ -2627,11 +2627,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     auto isolation = getActorIsolation(const_cast<ValueDecl *>(VD));
 
     switch (isolation.getKind()) {
-    case ActorIsolation::DistributedActorInstance: {
-      // TODO: implicitlyThrowing here for distributed
-      LLVM_FALLTHROUGH; // continue the ActorInstance checks
-    }
     case ActorIsolation::ActorInstance: {
+        // TODO: implicitlyThrowing here for distributed
       if (IsCrossActorReference) {
         implicitlyAsync = true;
         // TODO: 'NotRecommended' if this is a r-value reference.

lib/SILGen/SILGenConstructor.cpp

@@ -343,7 +343,6 @@ static bool ctorHopsInjectedByDefiniteInit(ConstructorDecl *ctor,
   // must be instance isolated
   switch (isolation) {
     case ActorIsolation::ActorInstance:
-    case ActorIsolation::DistributedActorInstance:
       return true;
 
     case ActorIsolation::Unspecified:

lib/SILGen/SILGenDistributed.cpp

@@ -568,7 +568,7 @@ void SILGenFunction::emitDistributedActorClassMemberDestruction(
     B.emitBlock(remoteMemberDestroyBB);
 
     for (VarDecl *vd : cd->getStoredProperties()) {
-      if (getActorIsolation(vd) == ActorIsolation::DistributedActorInstance)
+      if (getActorIsolation(vd) == ActorIsolation::ActorInstance)
         continue;
 
       destroyClassMember(cleanupLoc, selfValue, vd);

lib/SILGen/SILGenProlog.cpp

@@ -532,7 +532,6 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
       if (auto destructor = dyn_cast<DestructorDecl>(dc)) {
         switch (getActorIsolation(destructor)) {
         case ActorIsolation::ActorInstance:
-        case ActorIsolation::DistributedActorInstance:
           return true;
 
         case ActorIsolation::GlobalActor:
@@ -601,11 +600,6 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
       }
       break;
 
-    case ActorIsolation::DistributedActorInstance: {
-      // TODO: perhaps here we can emit our special handling to make a message?
-      LLVM_FALLTHROUGH;
-    }
-
     case ActorIsolation::ActorInstance: {
       // Only produce an executor for actor-isolated functions that are async
       // or are local functions. The former require a hop, while the latter
@@ -804,8 +798,7 @@ Optional<SILValue> SILGenFunction::emitExecutor(
   case ActorIsolation::Independent:
     return None;
 
-  case ActorIsolation::ActorInstance:
-  case ActorIsolation::DistributedActorInstance: {
+  case ActorIsolation::ActorInstance: {
     // "self" here means the actor instance's "self" value.
     assert(maybeSelf.hasValue() && "actor-instance but no self provided?");
     auto self = maybeSelf.getValue();

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -925,7 +925,6 @@ void LifetimeChecker::injectActorHops() {
   // Must be an initializer that is isolated to self.
   switch (getActorIsolation(ctor)) {
     case ActorIsolation::ActorInstance:
-    case ActorIsolation::DistributedActorInstance:
       break;
 
     case ActorIsolation::Unspecified:

lib/Sema/TypeCheckConcurrency.cpp

@@ -107,7 +107,6 @@ static bool requiresFlowIsolation(ActorIsolation typeIso,
       return false;
 
     case ActorIsolation::ActorInstance:
-    case ActorIsolation::DistributedActorInstance:
       return !(ctor->hasAsync()); // need flow-isolation for non-async.
   };
 }
@@ -137,10 +136,7 @@ bool swift::usesFlowSensitiveIsolation(AbstractFunctionDecl const *fn) {
       return true;
 
     // construct an isolation corresponding to the type.
-    auto actorTypeIso =
-      nominal->isDistributedActor()
-        ? ActorIsolation::forDistributedActorInstance(nominal)
-        : ActorIsolation::forActorInstance(nominal);
+    auto actorTypeIso = ActorIsolation::forActorInstance(nominal);
 
     return requiresFlowIsolation(actorTypeIso, cast<ConstructorDecl>(fn));
   }
@@ -519,10 +515,6 @@ ActorIsolationRestriction ActorIsolationRestriction::forDeclaration(
       return forActorSelf(isolation.getActor(),
           isAccessibleAcrossActors || isa<ConstructorDecl>(decl));
 
-    case ActorIsolation::DistributedActorInstance:
-      return forDistributedActorSelf(isolation.getActor(),
-       /*isCrossActor*/ isAccessibleAcrossActors || isa<ConstructorDecl>(decl));
-
     case ActorIsolation::GlobalActorUnsafe:
     case ActorIsolation::GlobalActor: {
       // A global-actor-isolated function referenced within an expression
@@ -1885,7 +1877,6 @@ namespace {
               var, isPotentiallyIsolated, isolation.getGlobalActor());
 
         case ActorIsolation::ActorInstance:
-        case ActorIsolation::DistributedActorInstance:
           break;
         }
       }
@@ -1928,7 +1919,6 @@ namespace {
             (!fn->isAsyncContext() || fn != dc)) {
           switch (getActorIsolation(fn)) {
           case ActorIsolation::ActorInstance:
-          case ActorIsolation::DistributedActorInstance:
           case ActorIsolation::GlobalActor:
           case ActorIsolation::GlobalActorUnsafe:
           case ActorIsolation::Independent:
@@ -2113,7 +2103,6 @@ namespace {
       // Retrieve the actor isolation of the context.
       switch (auto isolation = getActorIsolationOfContext(dc)) {
       case ActorIsolation::ActorInstance:
-      case ActorIsolation::DistributedActorInstance:
       case ActorIsolation::Independent:
       case ActorIsolation::Unspecified:
         return isolation;
@@ -2375,7 +2364,6 @@ namespace {
                 unsatisfiedIsolation->getGlobalActor()));
           break;
 
-        case ActorIsolation::DistributedActorInstance:
         case ActorIsolation::ActorInstance:
           apply->setImplicitlyAsync(
             ImplicitActorHopTarget::forIsolatedParameter(*isolatedParamIdx));
@@ -2454,7 +2442,6 @@ namespace {
 
       // Diagnose failures.
       switch (contextIsolation) {
-      case ActorIsolation::DistributedActorInstance:
       case ActorIsolation::ActorInstance: {
         auto useKind = static_cast<unsigned>(
             kindOfUsage(value, context).getValueOr(VarRefUseEnv::Read));
@@ -2988,8 +2975,7 @@ namespace {
         return ClosureActorIsolation::forGlobalActor(globalActorType);
       }
 
-      case ActorIsolation::ActorInstance:
-      case ActorIsolation::DistributedActorInstance: {
+      case ActorIsolation::ActorInstance: {
         if (auto param = closure->getCaptureInfo().getIsolatedParamCapture())
           return ClosureActorIsolation::forActorInstance(param);
 
@@ -3199,7 +3185,6 @@ static Optional<ActorIsolation> getIsolationFromWitnessedRequirements(
       auto requirementIsolation = getActorIsolation(requirement);
       switch (requirementIsolation) {
       case ActorIsolation::ActorInstance:
-      case ActorIsolation::DistributedActorInstance:
       case ActorIsolation::Unspecified:
         continue;
 
@@ -3227,7 +3212,6 @@ static Optional<ActorIsolation> getIsolationFromWitnessedRequirements(
     auto isolation = std::get<1>(isolated);
     switch (isolation) {
       case ActorIsolation::ActorInstance:
-      case ActorIsolation::DistributedActorInstance:
         llvm_unreachable("protocol requirements cannot be actor instances");
 
       case ActorIsolation::Independent:
@@ -3279,7 +3263,6 @@ static Optional<ActorIsolation> getIsolationFromConformances(
        nominal->getLocalProtocols(ConformanceLookupKind::NonStructural)) {
     switch (auto protoIsolation = getActorIsolation(proto)) {
     case ActorIsolation::ActorInstance:
-    case ActorIsolation::DistributedActorInstance:
     case ActorIsolation::Unspecified:
     case ActorIsolation::Independent:
       break;
@@ -3330,7 +3313,6 @@ static Optional<ActorIsolation> getIsolationFromWrappers(
 
     switch (isolation) {
     case ActorIsolation::ActorInstance:
-    case ActorIsolation::DistributedActorInstance:
     case ActorIsolation::Unspecified:
     case ActorIsolation::Independent:
       break;
@@ -3519,7 +3501,6 @@ static bool checkClassGlobalActorIsolation(
     return false;
 
   case ActorIsolation::ActorInstance:
-  case ActorIsolation::DistributedActorInstance:
     // This is an error that will be diagnosed later. Ignore it here.
     return false;
 
@@ -3553,9 +3534,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
   if (evaluateOrDefault(evaluator, HasIsolatedSelfRequest{value}, false)) {
     auto actor = value->getDeclContext()->getSelfNominalTypeDecl();
     assert(actor && "could not find the actor that 'self' is isolated to");
-    return actor->isDistributedActor()
-        ? ActorIsolation::forDistributedActorInstance(actor)
-        : ActorIsolation::forActorInstance(actor);
+    return ActorIsolation::forActorInstance(actor);
   }
 
   auto isolationFromAttr = getIsolationFromAttributes(value);
@@ -3647,7 +3626,6 @@ ActorIsolation ActorIsolationRequest::evaluate(
       break;
     }
 
-    case ActorIsolation::DistributedActorInstance:
     case ActorIsolation::ActorInstance:
     case ActorIsolation::Unspecified:
       if (onlyGlobal)
@@ -3680,7 +3658,6 @@ ActorIsolation ActorIsolationRequest::evaluate(
         break;
 
       case ActorIsolation::ActorInstance:
-      case ActorIsolation::DistributedActorInstance:
         if (auto param = func->getCaptureInfo().getIsolatedParamCapture())
           return inferredIsolation(enclosingIsolation);
         break;
@@ -3860,7 +3837,6 @@ bool HasIsolatedSelfRequest::evaluate(
       return false;
 
     case ActorIsolation::ActorInstance:
-    case ActorIsolation::DistributedActorInstance:
       if (isolation.getActor() != selfTypeDecl)
         return false;
       break;
@@ -3919,8 +3895,7 @@ void swift::checkOverrideActorIsolation(ValueDecl *value) {
   // the equality case above because the nominal type describing the actor
   // will differ when we're overriding.
   if (isolation.getKind() == overriddenIsolation.getKind() &&
-      (isolation.getKind() == ActorIsolation::ActorInstance ||
-       isolation.getKind() == ActorIsolation::DistributedActorInstance))
+      isolation.getKind() == ActorIsolation::ActorInstance)
     return;
 
   // If the overridden declaration is from Objective-C with no actor annotation,
@@ -4171,7 +4146,6 @@ bool swift::checkSendableConformance(
   switch (getActorIsolation(nominal)) {
   case ActorIsolation::Unspecified:
   case ActorIsolation::ActorInstance:
-  case ActorIsolation::DistributedActorInstance:
   case ActorIsolation::Independent:
     break;
 
@@ -4574,7 +4548,6 @@ AnyFunctionType *swift::adjustFunctionTypeForConcurrency(
   if (decl) {
     switch (auto isolation = getActorIsolation(decl)) {
     case ActorIsolation::ActorInstance:
-    case ActorIsolation::DistributedActorInstance:
     case ActorIsolation::Independent:
     case ActorIsolation::Unspecified:
       return fnType;

lib/Sema/TypeCheckPropertyWrapper.cpp

@@ -89,7 +89,6 @@ static VarDecl *findValueProperty(ASTContext &ctx, NominalTypeDecl *nominal,
   // The property must not be isolated to an actor instance.
   switch (auto isolation = getActorIsolation(var)) {
   case ActorIsolation::ActorInstance:
-  case ActorIsolation::DistributedActorInstance:
     var->diagnose(
         diag::actor_instance_property_wrapper, var->getName(),
         nominal->getName());

lib/Sema/TypeCheckProtocol.cpp

@@ -2937,12 +2937,13 @@ bool ConformanceChecker::checkActorIsolation(
 
     // An actor-isolated witness can only conform to an actor-isolated
     // requirement.
-    if (requirementIsolation == ActorIsolation::ActorInstance) {
+    auto requirementFunc = dyn_cast<AbstractFunctionDecl>(requirement);
+    if (requirementIsolation == ActorIsolation::ActorInstance &&
+        !(requirementFunc && requirementFunc->isDistributed())) {
       return false;
     }
 
     auto witnessFunc = dyn_cast<AbstractFunctionDecl>(witness);
-    auto requirementFunc = dyn_cast<AbstractFunctionDecl>(requirement);
     auto nominal = dyn_cast<NominalTypeDecl>(witness->getDeclContext());
     auto witnessClass = dyn_cast<ClassDecl>(witness->getDeclContext());
     if (auto extension = dyn_cast<ExtensionDecl>(witness->getDeclContext())) {
@@ -3170,11 +3171,6 @@ bool ConformanceChecker::checkActorIsolation(
   switch (auto requirementIsolation = getActorIsolation(requirement)) {
   case ActorIsolation::ActorInstance:
     llvm_unreachable("There are not actor protocols");
-  case ActorIsolation::DistributedActorInstance:
-    // A requirement inside a distributed actor, where it has a protocol that was
-    // bound requiring a `DistributedActor` conformance (`protocol D: DistributedActor`),
-    // results in the requirement being isolated to given distributed actor.
-    break;
 
   case ActorIsolation::GlobalActorUnsafe:
     requirementIsUnsafe = true;