[Concurrency] Prohibit partial application of actor-isolated methods.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4149,6 +4149,9 @@ ERROR(actor_isolated_self_independent_context,none,
         "actor-isolated %0 %1 can not be referenced from an "
         "'@actorIndependent' context",
         (DescriptiveDeclKind, DeclName))
+ERROR(actor_isolated_partial_apply,none,
+        "actor-isolated %0 %1 can not be partially applied",
+        (DescriptiveDeclKind, DeclName))
 WARNING(concurrent_access_local,none,
         "local %0 %1 is unsafe to reference in code that may execute "
         "concurrently",

lib/Sema/CSApply.cpp

@@ -925,7 +925,6 @@ namespace {
 
       case ValueOwnership::Owned:
       case ValueOwnership::Shared:
-        // Ensure that the argument type matches up exactly.
         auto selfArgTy = ParenType::get(context,
                                         selfParam.getPlainType(),
                                         selfParam.getParameterFlags());

lib/Sema/TypeCheckConcurrency.cpp

@@ -566,6 +566,25 @@ void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
         return false;
 
       case IsolationRestriction::ActorSelf: {
+        // Cannot refer to actor-isolated state in a partial application.
+        if (auto autoclosure = dyn_cast<AutoClosureExpr>(getDeclContext())) {
+          switch (autoclosure->getThunkKind()) {
+          case AutoClosureExpr::Kind::DoubleCurryThunk:
+          case AutoClosureExpr::Kind::SingleCurryThunk:
+            ctx.Diags.diagnose(
+                memberLoc, diag::actor_isolated_partial_apply,
+                member->getDescriptiveKind(),
+                member->getName());
+            noteIsolatedActorMember(member);
+            return true;
+
+          case AutoClosureExpr::Kind::None:
+            // Not in a partial application.
+            break;
+          }
+        }
+
+        // Must reference actor-isolated state on 'self'.
         auto selfVar = getSelfReference(base);
         if (!selfVar) {
           ctx.Diags.diagnose(

test/Concurrency/actor_isolation.swift

@@ -13,7 +13,7 @@ func acceptEscapingClosure<T>(_: @escaping () -> T) { }
 actor class MySuperActor {
   var superState: Int = 25
 
-  func superMethod() { }
+  func superMethod() { } // expected-note 2 {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
   func superAsyncMethod() async { }
 
   subscript (index: Int) -> String { // expected-note{{subscript declared here}}
@@ -28,7 +28,7 @@ actor class MyActor: MySuperActor {
   class func synchronousClass() { }
   static func synchronousStatic() { }
 
-  func synchronous() -> String { text.first ?? "nothing" } // expected-note 6{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  func synchronous() -> String { text.first ?? "nothing" } // expected-note 8{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
   func asynchronous() async -> String { synchronous() }
 }
 
@@ -46,6 +46,7 @@ extension MyActor {
     // @actorIndependent
     _ = actorIndependentFunc(otherActor: self)
     _ = actorIndependentVar
+
     actorIndependentVar = 17
     _ = self.actorIndependentFunc(otherActor: self)
     _ = self.actorIndependentVar
@@ -60,6 +61,10 @@ extension MyActor {
     _ = immutableGlobal
     _ = mutableGlobal // expected-warning{{reference to var 'mutableGlobal' is not concurrency-safe because it involves shared mutable state}}
 
+    // Partial application
+    _ = synchronous  // expected-error{{actor-isolated instance method 'synchronous()' can not be partially applied}}
+    _ = super.superMethod // expected-error{{actor-isolated instance method 'superMethod()' can not be partially applied}}
+
     return 5
   }
 
@@ -137,6 +142,10 @@ extension MyActor {
     }
 
     localVar = 0
+
+    // Partial application
+    _ = synchronous  // expected-error{{actor-isolated instance method 'synchronous()' can not be partially applied}}
+    _ = super.superMethod // expected-error{{actor-isolated instance method 'superMethod()' can not be partially applied}}
   }
 }