Remove unnecessary 'distributed' checks in actor isolation code.

Remove a few places where we are introducing extra distributed-related
actor isolation checking that either isn't necesssary or is incorrect.
Specifically:

* Hopping to a global actor *from* a distributed-actor isolated context
does not go through a distributed thunk (global actors can't have one).
* "Unrestricted" declarations are always unrestricted, so we don't
need an extra distributed check here (it won't ever occur).
* Actor isolation computation doesn't need a special case for
distributed; it marks too much, overriding (e.g.) global actor
isolation.

The primary semantic change visible here is that distributed actors
can now have truly 'nonisolated' members. They aren't required to be
'distributed' because they can't touch state anyway.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -1871,9 +1871,6 @@ namespace {
 
       switch (contextIsolation) {
       case ActorIsolation::DistributedActorInstance:
-        markNearestCallAsImplicitly(/*setAsync*/None, /*setThrows*/false,
-                                    /*setDistributedThunk*/true);
-        LLVM_FALLTHROUGH;
       case ActorIsolation::ActorInstance: {
         auto result = tryMarkImplicitlyAsync(
           loc, valueRef, context,
@@ -2234,28 +2231,8 @@ namespace {
       switch (auto isolation =
                   ActorIsolationRestriction::forDeclaration(
                     memberRef, getDeclContext())) {
-      case ActorIsolationRestriction::Unrestricted: {
-        // If a cross-actor reference is to an isolated actor, it's not
-        // crossing actors.
-        if (getIsolatedActor(base))
-          return false;
-
-        // Always fine to invoke constructors from outside of actors.
-        if (dyn_cast<ConstructorDecl>(member))
-          return false;
-
-        // While the member may be unrestricted, perhaps it is in a
-        // distributed actor, in which case we need to diagnose it.
-        if (auto classDecl = dyn_cast<ClassDecl>(member->getDeclContext())) {
-          if (classDecl->isDistributedActor()) {
-            ctx.Diags.diagnose(memberLoc, diag::distributed_actor_isolated_method);
-            noteIsolatedActorMember(member, context);
-            return true;
-          }
-        }
-
+      case ActorIsolationRestriction::Unrestricted:
         return false;
-      }
 
       case ActorIsolationRestriction::CrossDistributedActorSelf:
       case ActorIsolationRestriction::CrossActorSelf: {
@@ -3078,13 +3055,6 @@ ActorIsolation ActorIsolationRequest::evaluate(
     if (func->isSendable()) {
       defaultIsolation = ActorIsolation::forIndependent();
     }
-
-    if (auto nominal = value->getDeclContext()->getSelfNominalTypeDecl()) {
-      /// Unless the function is static, it is isolated to the dist actor
-      if (nominal->isDistributedActor() && !func->isStatic()) {
-        defaultIsolation = ActorIsolation::forDistributedActorInstance(nominal);
-      }
-    }
   }
 
   // An actor's convenience init is assumed to be actor-independent.

test/Distributed/distributed_actor_isolation.swift

@@ -91,9 +91,8 @@ distributed actor DistributedActor_1 {
 
   static func staticFunc() -> String { "" } // ok
 
-// TODO: should be able to handle a static, global actor isolated function as well
-//  @MainActor
-//  static func staticMainActorFunc() -> String { "" } // ok
+  @MainActor
+  static func staticMainActorFunc() -> String { "" } // ok
 
   static distributed func staticDistributedFunc() -> String {
     // expected-error@-1{{'distributed' functions cannot be 'static'}}{10-21=}
@@ -115,6 +114,9 @@ distributed actor DistributedActor_1 {
     await self.distHelloAsync()
     try self.distHelloThrows()
     try await self.distHelloAsyncThrows()
+
+    // Hops over to the global actor.
+    _ = await DistributedActor_1.staticMainActorFunc()
   }
 }
 

test/Distributed/distributed_actor_nonisolated.swift

@@ -15,8 +15,6 @@ distributed actor DA {
   // expected-error@-1{{'nonisolated' can not be applied to distributed actor stored properties}}
 
   nonisolated var computedNonisolated: Int {
-    // expected-note@-1{{distributed actor state is only available within the actor instance}}
-
     // nonisolated computed properties are outside of the actor and as such cannot access local
     _ = self.local // expected-error{{distributed actor-isolated property 'local' can only be referenced inside the distributed actor}}
 
@@ -33,7 +31,7 @@ distributed actor DA {
     // self is a distributed actor self is NOT isolated
     _ = self.local // expected-error{{distributed actor-isolated property 'local' can only be referenced inside the distributed actor}}
     _ = try await self.dist() // ok, was made implicitly throwing and async
-    _ = self.computedNonisolated // expected-error{{only 'distributed' functions can be called from outside the distributed actor}}
+    _ = self.computedNonisolated // it's okay, only the body of computedNonisolated is wrong
   }
 
   nonisolated distributed func nonisolatedDistributed() async {
@@ -46,4 +44,4 @@ distributed actor DA {
     fatalError()
   }
 
-}
+}

test/Distributed/distributed_protocol_isolation.swift

@@ -27,7 +27,7 @@ protocol DistProtocol: DistributedActor {
 @available(SwiftStdlib 5.5, *)
 distributed actor SpecificDist: DistProtocol {
 
-  nonisolated func local() -> String { "hi" } // expected-note{{only 'distributed' functions can be called from outside the distributed actor}}
+  nonisolated func local() -> String { "hi" }
 
   distributed func dist() -> String { "dist!" }
   distributed func dist(string: String) -> String { string }
@@ -49,7 +49,7 @@ distributed actor SpecificDist: DistProtocol {
 
 @available(SwiftStdlib 5.5, *)
 func outside_good(dp: SpecificDist) async throws {
-  _ = dp.local() // expected-error{{only 'distributed' functions can be called from outside the distributed actor}}
+  _ = dp.local()
 
   _ = try await dp.dist() // implicit async throws
   _ = try await dp.dist(string: "") // implicit async throws