@concurrent functions are actor-independent

Concurrent functions need to be actor-independent because they wouldn't
ever be safe to run concurrently while isolated on an actor. This
allows us to elimate the "may execute concurrently with" check related
to actor isolation, which is a cleaner overall story.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4257,10 +4257,6 @@ WARNING(concurrent_access_local,none,
         "local %0 %1 is unsafe to reference in code that may execute "
         "concurrently",
         (DescriptiveDeclKind, DeclName))
-ERROR(actor_isolated_concurrent_access,none,
-        "actor-isolated %0 %1 is unsafe to reference in code "
-        "that may execute concurrently",
-        (DescriptiveDeclKind, DeclName))
 ERROR(actor_isolated_from_concurrent_closure,none,
         "actor-isolated %0 %1 cannot be referenced from a concurrent closure",
         (DescriptiveDeclKind, DeclName))

lib/Sema/TypeCheckConcurrency.cpp

@@ -1372,17 +1372,6 @@ namespace {
             return true;
         }
 
-        // Check whether we are in a context that will not execute concurrently
-        // with the context of 'self'.
-        if (mayExecuteConcurrentlyWith(
-                getDeclContext(), selfVar->getDeclContext())) {
-          ctx.Diags.diagnose(
-              memberLoc, diag::actor_isolated_concurrent_access,
-              member->getDescriptiveKind(), member->getName());
-          noteIsolatedActorMember(member);
-          return true;
-        }
-
         // It's fine.
         return false;
       }
@@ -1809,6 +1798,14 @@ ActorIsolation ActorIsolationRequest::evaluate(
   // overridden by other inference rules.
   ActorIsolation defaultIsolation = ActorIsolation::forUnspecified();
 
+  // A @concurrent function is assumed to be actor-independent.
+  if (auto func = dyn_cast<AbstractFunctionDecl>(value)) {
+    if (func->isConcurrent()) {
+      defaultIsolation = ActorIsolation::forIndependent(
+          ActorIndependentKind::Safe);
+    }
+  }
+
   // Check for instance members of actor classes, which are part of
   // actor-isolated state.
   auto classDecl = value->getDeclContext()->getSelfClassDecl();

test/Concurrency/actor_isolation.swift

@@ -156,8 +156,8 @@ extension MyActor {
 
     // Local functions might run concurrently.
     @concurrent func localFn1() {
-      _ = self.text[0] // expected-error{{actor-isolated property 'text' is unsafe to reference in code that may execute concurrently}}
-      _ = self.synchronous() // expected-error{{actor-isolated instance method 'synchronous()' is unsafe to reference in code that may execute concurrently}}
+      _ = self.text[0] // expected-error{{actor-isolated property 'text' cannot be referenced from a concurrent function}}
+      _ = self.synchronous() // expected-error{{actor-isolated instance method 'synchronous()' cannot be referenced from a concurrent function}}
       _ = localVar // expected-warning{{local var 'localVar' is unsafe to reference in code that may execute concurrently}}
       _ = localConstant
     }