Merge pull request #35282 from slavapestov/actor-isolation-lazy-init

AST: Fix actor isolation checking for lazy property initializers

Author: slavapestov

include/swift/AST/ActorIsolation.h

@@ -152,6 +152,9 @@ class ActorIsolation {
 /// Determine how the given value declaration is isolated.
 ActorIsolation getActorIsolation(ValueDecl *value);
 
+/// Determine how the given declaration context is isolated.
+ActorIsolation getActorIsolationOfContext(DeclContext *dc);
+
 void simple_display(llvm::raw_ostream &out, const ActorIsolation &state);
 
 } // end namespace swift

lib/AST/Decl.cpp

@@ -7976,6 +7976,25 @@ void ClassDecl::setSuperclass(Type superclass) {
     true);
 }
 
+ActorIsolation swift::getActorIsolation(ValueDecl *value) {
+  auto &ctx = value->getASTContext();
+  return evaluateOrDefault(
+      ctx.evaluator, ActorIsolationRequest{value},
+      ActorIsolation::forUnspecified());
+}
+
+ActorIsolation swift::getActorIsolationOfContext(DeclContext *dc) {
+  if (auto *vd = dyn_cast_or_null<ValueDecl>(dc->getAsDecl()))
+    return getActorIsolation(vd);
+
+  if (auto *init = dyn_cast<PatternBindingInitializer>(dc)) {
+    if (auto *var = init->getBinding()->getSingleVar())
+      return getActorIsolation(var);
+  }
+
+  return ActorIsolation::forUnspecified();
+}
+
 ClangNode Decl::getClangNodeImpl() const {
   assert(Bits.Decl.FromClang);
   void * const *ptr = nullptr;

lib/Sema/TypeCheckConcurrency.cpp

@@ -852,8 +852,9 @@ namespace {
     }
 
   private:
-    /// If the expression is a reference to `self`, return the 'self' parameter.
-    static VarDecl *getSelfReference(Expr *expr) {
+    /// If the expression is a reference to `self`, return the context of
+    /// the 'self' parameter.
+    static DeclContext *getSelfReferenceContext(Expr *expr) {
       // Look through identity expressions and implicit conversions.
       Expr *prior;
       do {
@@ -867,13 +868,25 @@ namespace {
 
       // 'super' references always act on self.
       if (auto super = dyn_cast<SuperRefExpr>(expr))
-        return super->getSelf();
+        return super->getSelf()->getDeclContext();
 
       // Declaration references to 'self'.
       if (auto declRef = dyn_cast<DeclRefExpr>(expr)) {
-        if (auto var = dyn_cast<VarDecl>(declRef->getDecl()))
+        if (auto var = dyn_cast<VarDecl>(declRef->getDecl())) {
           if (var->isSelfParameter())
-            return var;
+            return var->getDeclContext();
+
+          // If this is a 'self' capture in a capture list, recurse through
+          // the capture list entry's initializer to find the original 'self'.
+          if (var->isSelfParamCapture()) {
+            for (auto capture : var->getParentCaptureList()->getCaptureList()) {
+              if (capture.Var == var) {
+                expr = capture.Init->getInit(0);
+                return getSelfReferenceContext(expr);
+              }
+            }
+          }
+        }
       }
 
       // Not a self reference.
@@ -1250,8 +1263,8 @@ namespace {
 
       case ActorIsolationRestriction::ActorSelf: {
         // Must reference actor-isolated state on 'self'.
-        auto selfVar = getSelfReference(base);
-        if (!selfVar) {
+        auto *selfDC = getSelfReferenceContext(base);
+        if (!selfDC) {
           // actor-isolated non-self calls are implicitly async and thus OK.
           if (maybeImplicitAsync && isa<AbstractFunctionDecl>(member)) {
             markNearestCallAsImplicitlyAsync();
@@ -1268,8 +1281,7 @@ namespace {
         }
 
         // Check whether the context of 'self' is actor-isolated.
-        switch (auto contextIsolation = getActorIsolation(
-                   cast<ValueDecl>(selfVar->getDeclContext()->getAsDecl()))) {
+        switch (auto contextIsolation = getActorIsolationOfContext(selfDC)) {
           case ActorIsolation::ActorInstance:
             // An escaping partial application of something that is part of
             // the actor's isolated state is never permitted.
@@ -1312,8 +1324,7 @@ namespace {
 
         // Check whether we are in a context that will not execute concurrently
         // with the context of 'self'.
-        if (mayExecuteConcurrentlyWith(
-                getDeclContext(), selfVar->getDeclContext())) {
+        if (mayExecuteConcurrentlyWith(getDeclContext(), selfDC)) {
           ctx.Diags.diagnose(
               memberLoc, diag::actor_isolated_concurrent_access,
               member->getDescriptiveKind(), member->getName());
@@ -1886,13 +1897,6 @@ ActorIsolation ActorIsolationRequest::evaluate(
   return defaultIsolation;
 }
 
-ActorIsolation swift::getActorIsolation(ValueDecl *value) {
-  auto &ctx = value->getASTContext();
-  return evaluateOrDefault(
-      ctx.evaluator, ActorIsolationRequest{value},
-      ActorIsolation::forUnspecified());
-}
-
 void swift::checkOverrideActorIsolation(ValueDecl *value) {
   if (isa<TypeDecl>(value))
     return;

test/Concurrency/actor_isolation.swift

@@ -367,3 +367,43 @@ func checkLocalFunctions() async {
 
   print(k)
 }
+
+// ----------------------------------------------------------------------
+// Lazy properties with initializers referencing 'self'
+// ----------------------------------------------------------------------
+
+actor class LazyActor {
+    var v: Int = 0
+    // expected-note@-1 5 {{mutable state is only available within the actor instance}}
+
+    let l: Int = 0
+
+    lazy var l11: Int = { v }()
+    lazy var l12: Int = v
+    lazy var l13: Int = { self.v }()
+    lazy var l14: Int = self.v
+    lazy var l15: Int = { [unowned self] in self.v }()
+
+    lazy var l21: Int = { l }()
+    lazy var l22: Int = l
+    lazy var l23: Int = { self.l }()
+    lazy var l24: Int = self.l
+    lazy var l25: Int = { [unowned self] in self.l }()
+
+    @actorIndependent lazy var l31: Int = { v }()
+    // expected-error@-1 {{actor-isolated property 'v' can not be referenced from an '@actorIndependent' context}}
+    @actorIndependent lazy var l32: Int = v
+    // expected-error@-1 {{actor-isolated property 'v' can not be referenced from an '@actorIndependent' context}}
+    @actorIndependent lazy var l33: Int = { self.v }()
+    // expected-error@-1 {{actor-isolated property 'v' can not be referenced from an '@actorIndependent' context}}
+    @actorIndependent lazy var l34: Int = self.v
+    // expected-error@-1 {{actor-isolated property 'v' can not be referenced from an '@actorIndependent' context}}
+    @actorIndependent lazy var l35: Int = { [unowned self] in self.v }()
+    // expected-error@-1 {{actor-isolated property 'v' can not be referenced from an '@actorIndependent' context}}
+
+    @actorIndependent lazy var l41: Int = { l }()
+    @actorIndependent lazy var l42: Int = l
+    @actorIndependent lazy var l43: Int = { self.l }()
+    @actorIndependent lazy var l44: Int = self.l
+    @actorIndependent lazy var l45: Int = { [unowned self] in self.l }()
+}