[Concurrency] Handle non-escaping partial application.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -338,6 +338,69 @@ class IsolationRestriction {
 
 }
 
+namespace {
+  /// Describes the important parts of a partial apply thunk.
+  struct PartialApplyThunkInfo {
+    Expr *base;
+    Expr *fn;
+    bool isEscaping;
+  };
+}
+
+/// Try to decompose a call that might be an invocation of a partial apply
+/// thunk.
+static Optional<PartialApplyThunkInfo> decomposePartialApplyThunk(
+    ApplyExpr *apply, Expr *parent) {
+  // Check for a call to the outer closure in the thunk.
+  auto outerAutoclosure = dyn_cast<AutoClosureExpr>(apply->getFn());
+  if (!outerAutoclosure ||
+      outerAutoclosure->getThunkKind()
+        != AutoClosureExpr::Kind::DoubleCurryThunk)
+    return None;
+
+  // Check for the inner closure in the thunk.
+  auto innerAutoclosure = dyn_cast<AutoClosureExpr>(
+      outerAutoclosure->getSingleExpressionBody());
+  if (!innerAutoclosure ||
+      innerAutoclosure->getThunkKind()
+          != AutoClosureExpr::Kind::SingleCurryThunk)
+    return None;
+
+  auto innerCall = dyn_cast<CallExpr>(
+      innerAutoclosure->getSingleExpressionBody());
+  if (!innerCall)
+    return None;
+
+  auto memberCall = dyn_cast<DotSyntaxCallExpr>(innerCall->getFn());
+  if (!memberCall)
+    return None;
+
+  // Determine whether the partial apply thunk was immediately converted to
+  // noescape.
+  bool isEscaping = true;
+  if (auto conversion = dyn_cast_or_null<FunctionConversionExpr>(parent)) {
+    auto fnType = conversion->getType()->getAs<FunctionType>();
+    isEscaping = fnType && !fnType->isNoEscape();
+  }
+
+  return PartialApplyThunkInfo{
+      apply->getArg(), memberCall->getFn(), isEscaping};
+}
+
+/// Find the immediate member reference in the given expression.
+static Optional<std::pair<ValueDecl *, SourceLoc>>
+findMemberReference(Expr *expr) {
+  if (auto declRef = dyn_cast<DeclRefExpr>(expr))
+    return std::make_pair(declRef->getDecl(), declRef->getLoc());
+
+  if (auto otherCtor = dyn_cast<OtherConstructorDeclRefExpr>(expr)) {
+    return std::make_pair(
+        static_cast<ValueDecl *>(otherCtor->getDecl()), otherCtor->getLoc());
+  }
+
+  return None;
+}
+
 void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
   class ActorIsolationWalker : public ASTWalker {
     ASTContext &ctx;
@@ -377,18 +440,27 @@ void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
         return { true, expr };
       }
 
-      if (auto call = dyn_cast<SelfApplyExpr>(expr)) {
-        Expr *fn = call->getFn()->getValueProvidingExpr();
-        if (auto declRef = dyn_cast<DeclRefExpr>(fn)) {
-          checkMemberReference(
-              call->getArg(), declRef->getDecl(), declRef->getLoc());
-          call->getArg()->walk(*this);
-          return { false, expr };
+      if (auto apply = dyn_cast<ApplyExpr>(expr)) {
+        // If this is a call to a partial apply thunk, decompose it to check it
+        // like based on the original written syntax, e.g., "self.method".
+        if (auto partialApply = decomposePartialApplyThunk(
+                apply, Parent.getAsExpr())) {
+          if (auto memberRef = findMemberReference(partialApply->fn)) {
+            checkMemberReference(
+                partialApply->base, memberRef->first, memberRef->second,
+                partialApply->isEscaping);
+
+            partialApply->base->walk(*this);
+            return { false, expr };
+          }
         }
+      }
 
-        if (auto otherCtor = dyn_cast<OtherConstructorDeclRefExpr>(fn)) {
+      if (auto call = dyn_cast<SelfApplyExpr>(expr)) {
+        Expr *fn = call->getFn()->getValueProvidingExpr();
+        if (auto memberRef = findMemberReference(fn)) {
           checkMemberReference(
-              call->getArg(), otherCtor->getDecl(), otherCtor->getLoc());
+              call->getArg(), memberRef->first, memberRef->second);
           call->getArg()->walk(*this);
           return { false, expr };
         }
@@ -557,7 +629,8 @@ void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
 
     /// Check a reference with the given base expression to the given member.
     bool checkMemberReference(
-        Expr *base, ValueDecl *member, SourceLoc memberLoc) {
+        Expr *base, ValueDecl *member, SourceLoc memberLoc,
+        bool isEscapingPartialApply = false) {
       if (!base || !member)
         return false;
 
@@ -566,24 +639,6 @@ 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) {
@@ -602,6 +657,18 @@ void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
                    cast<ValueDecl>(selfVar->getDeclContext()->getAsDecl()))) {
           case ActorIsolation::ActorInstance:
           case ActorIsolation::ActorPrivileged:
+            // An escaping partial application of something that is part of
+            // the actor's isolated state is never permitted.
+            if (isEscapingPartialApply) {
+              ctx.Diags.diagnose(
+                  memberLoc, diag::actor_isolated_partial_apply,
+                  member->getDescriptiveKind(),
+                  member->getName());
+              noteIsolatedActorMember(member);
+              return true;
+            }
+            break;
+
           case ActorIsolation::Unspecified:
             // Okay
             break;
@@ -614,7 +681,7 @@ void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
                 member->getDescriptiveKind(),
                 member->getName());
             noteIsolatedActorMember(member);
-            break;
+            return true;
         }
 
         // Check whether we are in a context that will not execute concurrently

lib/Sema/TypeCheckEffects.cpp

@@ -1514,7 +1514,21 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
     ContextScope scope(*this, Context::forClosure(E));
     scope.enterSubFunction();
     scope.resetCoverageForAutoclosureBody();
+
+    // Curry thunks aren't actually a call to the asynchronous function.
+    // Assume that async is covered in such contexts.
+    switch (E->getThunkKind()) {
+    case AutoClosureExpr::Kind::DoubleCurryThunk:
+    case AutoClosureExpr::Kind::SingleCurryThunk:
+      Flags.set(ContextFlags::IsAsyncCovered);
+      break;
+
+    case AutoClosureExpr::Kind::None:
+      break;
+    }
+
     E->getBody()->walk(*this);
+
     scope.preserveCoverageFromAutoclosureBody();
     return ShouldNotRecurse;
   }

test/Concurrency/actor_isolation.swift

@@ -7,6 +7,9 @@ func globalFunc() { }
 func acceptClosure<T>(_: () -> T) { }
 func acceptEscapingClosure<T>(_: @escaping () -> T) { }
 
+func acceptAsyncClosure<T>(_: () async -> T) { }
+func acceptEscapingAsyncClosure<T>(_: @escaping () async -> T) { }
+
 // ----------------------------------------------------------------------
 // Actor state isolation restrictions
 // ----------------------------------------------------------------------
@@ -28,7 +31,7 @@ actor class MyActor: MySuperActor {
   class func synchronousClass() { }
   static func synchronousStatic() { }
 
-  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 synchronous() -> String { text.first ?? "nothing" } // expected-note 18{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
   func asynchronous() async -> String { synchronous() }
 }
 
@@ -62,8 +65,14 @@ extension MyActor {
     _ = 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}}
+    _ = synchronous  // expected-error{{actor-isolated instance method 'synchronous()' can not be referenced from an '@actorIndependent' context}}
+    _ = super.superMethod // expected-error{{actor-isolated instance method 'superMethod()' can not be referenced from an '@actorIndependent' context}}
+    acceptClosure(synchronous) // expected-error{{actor-isolated instance method 'synchronous()' can not be referenced from an '@actorIndependent' context}}
+    acceptClosure(self.synchronous) // expected-error{{actor-isolated instance method 'synchronous()' can not be referenced from an '@actorIndependent' context}}
+    acceptClosure(otherActor.synchronous) // expected-error{{actor-isolated instance method 'synchronous()' can only be referenced on 'self'}}
+    acceptEscapingClosure(synchronous) // expected-error{{actor-isolated instance method 'synchronous()' can not be referenced from an '@actorIndependent' context}}}}
+    acceptEscapingClosure(self.synchronous) // expected-error{{actor-isolated instance method 'synchronous()' can not be referenced from an '@actorIndependent'}}
+    acceptEscapingClosure(otherActor.synchronous) // expected-error{{actor-isolated instance method 'synchronous()' can only be referenced on 'self'}}
 
     return 5
   }
@@ -145,7 +154,16 @@ extension MyActor {
 
     // 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}}
+    _ = super.superMethod // expected-error{{actor-isolated instance method 'superMethod()' is unsafe to reference in code that may execute concurrently}}
+    acceptClosure(synchronous)
+    acceptClosure(self.synchronous)
+    acceptClosure(otherActor.synchronous) // expected-error{{actor-isolated instance method 'synchronous()' can only be referenced on 'self'}}
+    acceptEscapingClosure(synchronous) // expected-error{{actor-isolated instance method 'synchronous()' can not be partially applied}}
+    acceptEscapingClosure(self.synchronous) // expected-error{{actor-isolated instance method 'synchronous()' can not be partially applied}}
+    acceptEscapingClosure(otherActor.synchronous) // expected-error{{actor-isolated instance method 'synchronous()' can only be referenced on 'self'}}
+
+    acceptAsyncClosure(self.asynchronous)
+    acceptEscapingAsyncClosure(self.asynchronous)
   }
 }