Simplify 'inout' check for isolated actor state in async calls.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -1261,6 +1261,9 @@ ReferencedActor ReferencedActor::forGlobalActor(VarDecl *actor,
   return ReferencedActor(actor, isPotentiallyIsolated, kind, globalActor);
 }
 
+static ActorIsolation getActorIsolationForReference(
+    ValueDecl *decl, const DeclContext *fromDC);
+
 bool ReferencedActor::isKnownToBeLocal() const {
   switch (kind) {
   case GlobalActor:
@@ -2250,54 +2253,36 @@ namespace {
         return false;
 
       bool result = false;
-      auto checkDiagnostic = [this, call, isPartialApply,
-                              &result](ValueDecl *decl, SourceLoc argLoc) {
-        auto isolation = ActorIsolationRestriction::forDeclaration(
-            decl, getDeclContext());
-        switch (isolation) {
-        case ActorIsolationRestriction::Unrestricted:
-        case ActorIsolationRestriction::Unsafe:
-          break;
-        case ActorIsolationRestriction::GlobalActorUnsafe:
-          // If we're not supposed to diagnose existing data races here,
-          // we're done.
-          if (!shouldDiagnoseExistingDataRaces(getDeclContext()))
-            break;
-
-          LLVM_FALLTHROUGH;
+      auto checkDiagnostic = [this, call, isPartialApply, &result](
+          ConcreteDeclRef declRef, SourceLoc argLoc) {
+        auto decl = declRef.getDecl();
+        auto isolation = getActorIsolationForReference(decl, getDeclContext());
+        if (!isolation.isActorIsolated())
+          return;
 
-        case ActorIsolationRestriction::GlobalActor: {
-          ctx.Diags.diagnose(argLoc, diag::actor_isolated_inout_state,
-                             decl->getDescriptiveKind(), decl->getName(),
-                             call->isImplicitlyAsync().hasValue());
-          decl->diagnose(diag::kind_declared_here, decl->getDescriptiveKind());
-          result = true;
-          break;
-        }
-        case ActorIsolationRestriction::CrossActorSelf:
-        case ActorIsolationRestriction::ActorSelf: {
-          if (isPartialApply) {
-            // The partially applied InoutArg is a property of actor. This
-            // can really only happen when the property is a struct with a
-            // mutating async method.
-            if (auto partialApply = dyn_cast<ApplyExpr>(call->getFn())) {
-              ValueDecl *fnDecl =
-                  cast<DeclRefExpr>(partialApply->getFn())->getDecl();
+        if (isPartialApply) {
+          // The partially applied InoutArg is a property of actor. This
+          // can really only happen when the property is a struct with a
+          // mutating async method.
+          if (auto partialApply = dyn_cast<ApplyExpr>(call->getFn())) {
+            if (auto declRef = dyn_cast<DeclRefExpr>(partialApply->getFn())) {
+              ValueDecl *fnDecl = declRef->getDecl();
               ctx.Diags.diagnose(call->getLoc(),
                                  diag::actor_isolated_mutating_func,
                                  fnDecl->getName(), decl->getDescriptiveKind(),
                                  decl->getName());
               result = true;
+              return;
             }
-          } else {
-            ctx.Diags.diagnose(argLoc, diag::actor_isolated_inout_state,
-                               decl->getDescriptiveKind(), decl->getName(),
-                               call->isImplicitlyAsync().hasValue());
-            result = true;
           }
-          break;
-        }
         }
+
+        ctx.Diags.diagnose(argLoc, diag::actor_isolated_inout_state,
+                           decl->getDescriptiveKind(), decl->getName(),
+                           call->isImplicitlyAsync().hasValue());
+        decl->diagnose(diag::kind_declared_here, decl->getDescriptiveKind());
+        result = true;
+        return;
       };
       auto expressionWalker = [baseArg = arg->getSubExpr(),
                                checkDiagnostic](Expr *expr) -> Expr * {

test/Concurrency/actor_inout_isolation.swift

@@ -25,11 +25,11 @@ struct Point {
 @available(SwiftStdlib 5.1, *)
 actor TestActor {
   // expected-note@+1{{mutation of this property is only permitted within the actor}}
-  var position = Point(x: 0, y: 0)
-  var nextPosition = Point(x: 0, y: 1)
-  var value1: Int = 0
-  var value2: Int = 1
-  var points: [Point] = []
+  var position = Point(x: 0, y: 0) // expected-note 2{{property declared here}}
+  var nextPosition = Point(x: 0, y: 1) // expected-note 2{{property declared here}}
+  var value1: Int = 0 // expected-note 6{{property declared here}}
+  var value2: Int = 1 // expected-note 4{{property declared here}}
+  var points: [Point] = [] // expected-note {{property declared here}}
 
   subscript(x : inout Int) -> Int { // expected-error {{'inout' must not be used on subscript parameters}}
     x += 1
@@ -162,11 +162,11 @@ extension TestActor {
 
 @available(SwiftStdlib 5.1, *)
 actor MyActor {
-  var points: [Point] = []
-  var int: Int = 0
-  var maybeInt: Int?
-  var maybePoint: Point?
-  var myActor: TestActor = TestActor()
+  var points: [Point] = [] // expected-note 2{{property declared here}}
+  var int: Int = 0 // expected-note 2{{property declared here}}
+  var maybeInt: Int? // expected-note 1{{property declared here}}
+  var maybePoint: Point? // expected-note 1{{property declared here}}
+  var myActor: TestActor = TestActor() // expected-note 1{{property declared here}}
 
   // Checking that various ways of unwrapping emit the right error messages at
   // the right times and that illegal operations are caught