[Concurrency] Drop ActorIsolationRestriction::LocalCapture.

We are only interest in local captures in very narrow places, and they
aren't actually related to actor isolation at all. Drop this case and
check local captures in the one place they matter.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -530,9 +530,8 @@ ActorIsolationRestriction ActorIsolationRestriction::forDeclaration(
   case DeclKind::Func:
   case DeclKind::Subscript: {
     // Local captures are checked separately.
-    if (cast<ValueDecl>(decl)->isLocalCapture()) {
-      return forLocalCapture(decl->getDeclContext());
-    }
+    if (cast<ValueDecl>(decl)->isLocalCapture())
+      return forUnrestricted();
 
     // 'let' declarations are immutable, so they can be accessed across
     // actors.
@@ -1280,7 +1279,6 @@ namespace {
         auto isolation = ActorIsolationRestriction::forDeclaration(decl);
         switch (isolation) {
         case ActorIsolationRestriction::Unrestricted:
-        case ActorIsolationRestriction::LocalCapture:
         case ActorIsolationRestriction::Unsafe:
           break;
         case ActorIsolationRestriction::CrossGlobalActor:
@@ -1564,13 +1562,80 @@ namespace {
       return knownContexts->second.back();
     }
 
+    /// Check a reference to a local capture.
+    bool checkLocalCapture(
+        ConcreteDeclRef valueRef, SourceLoc loc, DeclRefExpr *declRefExpr) {
+      auto value = valueRef.getDecl();
+
+      // Check whether we are in a context that will not execute concurrently
+      // with the context of 'self'. If not, it's safe.
+      if (!mayExecuteConcurrentlyWith(
+              getDeclContext(), findCapturedDeclContext(value)))
+        return false;
+
+      // Check whether this is a local variable, in which case we can
+      // determine whether it was safe to access concurrently.
+      if (auto var = dyn_cast<VarDecl>(value)) {
+        auto parent = mutableLocalVarParent[declRefExpr];
+
+        // If the variable is immutable, it's fine so long as it involves
+        // ConcurrentValue types.
+        //
+        // When flow-sensitive concurrent captures are enabled, we also
+        // allow reads, depending on a SIL diagnostic pass to identify the
+        // remaining race conditions.
+        if (!var->supportsMutation() ||
+            (ctx.LangOpts.EnableExperimentalFlowSensitiveConcurrentCaptures &&
+             parent.dyn_cast<LoadExpr *>())) {
+          return diagnoseNonConcurrentTypesInReference(
+              valueRef, getDeclContext(), loc,
+              ConcurrentReferenceKind::LocalCapture);
+        }
+
+        // Otherwise, we have concurrent access. Complain.
+        ctx.Diags.diagnose(
+            loc, diag::concurrent_access_of_local_capture,
+            parent.dyn_cast<LoadExpr *>(),
+            var->getDescriptiveKind(), var->getName());
+        return true;
+      }
+
+      if (auto func = dyn_cast<FuncDecl>(value)) {
+        if (func->isConcurrent())
+          return false;
+
+        func->diagnose(
+            diag::local_function_executed_concurrently,
+            func->getDescriptiveKind(), func->getName())
+          .fixItInsert(func->getAttributeInsertionLoc(false), "@concurrent ");
+
+        // Add the @concurrent attribute implicitly, so we don't diagnose
+        // again.
+        const_cast<FuncDecl *>(func)->getAttrs().add(
+            new (ctx) ConcurrentAttr(true));
+        return true;
+      }
+
+      // Concurrent access to some other local.
+      ctx.Diags.diagnose(
+          loc, diag::concurrent_access_local,
+          value->getDescriptiveKind(), value->getName());
+      value->diagnose(
+          diag::kind_declared_here, value->getDescriptiveKind());
+      return true;
+    }
+
     /// Check a reference to a local or global.
     bool checkNonMemberReference(
         ConcreteDeclRef valueRef, SourceLoc loc, DeclRefExpr *declRefExpr) {
       if (!valueRef)
         return false;
 
       auto value = valueRef.getDecl();
+
+      if (value->isLocalCapture())
+        return checkLocalCapture(valueRef, loc, declRefExpr);
+
       switch (auto isolation =
                   ActorIsolationRestriction::forDeclaration(valueRef)) {
       case ActorIsolationRestriction::Unrestricted:
@@ -1586,64 +1651,6 @@ namespace {
             valueRef, loc, isolation.getGlobalActor(),
             isolation == ActorIsolationRestriction::CrossGlobalActor);
 
-      case ActorIsolationRestriction::LocalCapture:
-        // Check whether we are in a context that will not execute concurrently
-        // with the context of 'self'. If not, it's safe.
-        if (!mayExecuteConcurrentlyWith(
-                getDeclContext(), findCapturedDeclContext(value)))
-          return false;
-
-        // Check whether this is a local variable, in which case we can
-        // determine whether it was safe to access concurrently.
-        if (auto var = dyn_cast<VarDecl>(value)) {
-          auto parent = mutableLocalVarParent[declRefExpr];
-
-          // If the variable is immutable, it's fine so long as it involves
-          // ConcurrentValue types.
-          //
-          // When flow-sensitive concurrent captures are enabled, we also
-          // allow reads, depending on a SIL diagnostic pass to identify the
-          // remaining race conditions.
-          if (!var->supportsMutation() ||
-              (ctx.LangOpts.EnableExperimentalFlowSensitiveConcurrentCaptures &&
-               parent.dyn_cast<LoadExpr *>())) {
-            return diagnoseNonConcurrentTypesInReference(
-                valueRef, getDeclContext(), loc,
-                ConcurrentReferenceKind::LocalCapture);
-          }
-
-          // Otherwise, we have concurrent access. Complain.
-          ctx.Diags.diagnose(
-              loc, diag::concurrent_access_of_local_capture,
-              parent.dyn_cast<LoadExpr *>(),
-              var->getDescriptiveKind(), var->getName());
-          return true;
-        }
-
-        if (auto func = dyn_cast<FuncDecl>(value)) {
-          if (func->isConcurrent())
-            return false;
-
-          func->diagnose(
-              diag::local_function_executed_concurrently,
-              func->getDescriptiveKind(), func->getName())
-            .fixItInsert(func->getAttributeInsertionLoc(false), "@concurrent ");
-
-          // Add the @concurrent attribute implicitly, so we don't diagnose
-          // again.
-          const_cast<FuncDecl *>(func)->getAttrs().add(
-              new (ctx) ConcurrentAttr(true));
-          return true;
-        }
-
-        // Concurrent access to some other local.
-        ctx.Diags.diagnose(
-            loc, diag::concurrent_access_local,
-            value->getDescriptiveKind(), value->getName());
-        value->diagnose(
-            diag::kind_declared_here, value->getDescriptiveKind());
-        return true;
-
       case ActorIsolationRestriction::Unsafe:
         return diagnoseReferenceToUnsafeGlobal(value, loc);
       }
@@ -1794,9 +1801,6 @@ namespace {
             memberRef, memberLoc, isolation.getGlobalActor(),
             isolation == ActorIsolationRestriction::CrossGlobalActor);
 
-      case ActorIsolationRestriction::LocalCapture:
-        llvm_unreachable("Locals cannot be referenced with member syntax");
-
       case ActorIsolationRestriction::Unsafe:
         // This case is hit when passing actor state inout to functions in some
         // cases. The error is emitted by diagnoseInOutArg.

lib/Sema/TypeCheckConcurrency.h

@@ -77,10 +77,6 @@ class ActorIsolationRestriction {
     /// Access to the declaration is unsafe in a concurrent context.
     Unsafe,
 
-    /// The declaration is a local entity whose capture could introduce
-    /// data races. The context in which the local was defined is provided.
-    LocalCapture,
-
     /// References to this entity are allowed from anywhere, but doing so
     /// may cross an actor boundary if it is not on \c self.
     CrossActorSelf,
@@ -117,12 +113,6 @@ class ActorIsolationRestriction {
 public:
   Kind getKind() const { return kind; }
 
-  /// Retrieve the declaration context in which a local was defined.
-  DeclContext *getLocalContext() const {
-    assert(kind == LocalCapture);
-    return data.localContext;
-  }
-
   /// Retrieve the actor class that the declaration is within.
   ClassDecl *getActorClass() const {
     assert(kind == ActorSelf || kind == CrossActorSelf);
@@ -154,13 +144,6 @@ class ActorIsolationRestriction {
     return result;
   }
 
-  /// Access is restricted to code running within the given local context.
-  static ActorIsolationRestriction forLocalCapture(DeclContext *dc) {
-    ActorIsolationRestriction result(LocalCapture);
-    result.data.localContext = dc;
-    return result;
-  }
-
   /// Accesses to the given declaration can only be made via this particular
   /// global actor or is a cross-actor access.
   static ActorIsolationRestriction forGlobalActor(

lib/Sema/TypeCheckDeclObjC.cpp

@@ -413,7 +413,6 @@ static bool checkObjCActorIsolation(const ValueDecl *VD,
     // FIXME: Consider whether to limit @objc on global-actor-qualified
     // declarations.
   case ActorIsolationRestriction::Unrestricted:
-  case ActorIsolationRestriction::LocalCapture:
   case ActorIsolationRestriction::Unsafe:
     return false;
   }

lib/Sema/TypeCheckProtocol.cpp

@@ -2755,7 +2755,6 @@ bool ConformanceChecker::checkActorIsolation(
   }
 
   case ActorIsolationRestriction::Unsafe:
-  case ActorIsolationRestriction::LocalCapture:
     break;
 
   case ActorIsolationRestriction::Unrestricted: