Merge pull request swiftlang#35865 from DougGregor/initializer-actor-isolation

Author: DougGregor

lib/AST/Decl.cpp

@@ -6986,7 +6986,7 @@ AbstractFunctionDecl::getObjCSelector(DeclName preferredName,
     }
 
     // For the first selector piece, attach either the first parameter,
-    // "withCompletionHandker", or "AndReturnError" to the base name,
+    // "withCompletionHandler", or "AndReturnError" to the base name,
     // if appropriate.
     auto firstPiece = baseName;
     llvm::SmallString<32> scratch;
@@ -7999,7 +7999,8 @@ ActorIsolation swift::getActorIsolationOfContext(DeclContext *dc) {
     return getActorIsolation(vd);
 
   if (auto *init = dyn_cast<PatternBindingInitializer>(dc)) {
-    if (auto *var = init->getBinding()->getSingleVar())
+    if (auto *var = init->getBinding()->getAnchoringVarDecl(
+            init->getBindingIndex()))
       return getActorIsolation(var);
   }
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -491,11 +491,9 @@ ActorIsolationRestriction ActorIsolationRestriction::forDeclaration(
     // Types are always available.
     return forUnrestricted();
 
-  case DeclKind::Constructor:
   case DeclKind::EnumCase:
   case DeclKind::EnumElement:
     // Type-level entities don't require isolation.
-    // FIXME: This is incorrect due to global actors.
     return forUnrestricted();
 
   case DeclKind::IfConfig:
@@ -519,6 +517,7 @@ ActorIsolationRestriction ActorIsolationRestriction::forDeclaration(
   case DeclKind::Param:
   case DeclKind::Var:
   case DeclKind::Accessor:
+  case DeclKind::Constructor:
   case DeclKind::Func:
   case DeclKind::Subscript: {
     // Local captures can only be referenced in their local context or a
@@ -551,7 +550,8 @@ ActorIsolationRestriction ActorIsolationRestriction::forDeclaration(
     switch (auto isolation = getActorIsolation(cast<ValueDecl>(decl))) {
     case ActorIsolation::ActorInstance:
       // Protected actor instance members can only be accessed on 'self'.
-      return forActorSelf(isolation.getActor(), isAccessibleAcrossActors);
+      return forActorSelf(isolation.getActor(),
+          isAccessibleAcrossActors || isa<ConstructorDecl>(decl));
 
     case ActorIsolation::GlobalActor: {
       Type actorType = isolation.getGlobalActor();
@@ -2275,10 +2275,11 @@ ActorIsolation ActorIsolationRequest::evaluate(
     }
   }
 
-  // Check for instance members of actor classes, which are part of
-  // actor-isolated state.
+  // Check for instance members and initializers of actor classes,
+  // which are part of actor-isolated state.
   auto classDecl = value->getDeclContext()->getSelfClassDecl();
-  if (classDecl && classDecl->isActor() && value->isInstanceMember()) {
+  if (classDecl && classDecl->isActor() &&
+      (value->isInstanceMember() || isa<ConstructorDecl>(value))) {
     defaultIsolation = ActorIsolation::forActorInstance(classDecl);
   }
 
@@ -2366,8 +2367,8 @@ ActorIsolation ActorIsolationRequest::evaluate(
     }
   }
 
-  // Instance members can infer isolation from their context.
-  if (value->isInstanceMember()) {
+  // Instance members and initializers can infer isolation from their context.
+  if (value->isInstanceMember() || isa<ConstructorDecl>(value)) {
     // If the declaration is in an extension that has one of the isolation
     // attributes, use that.
     if (auto ext = dyn_cast<ExtensionDecl>(value->getDeclContext())) {

test/Concurrency/actor_isolation.swift

@@ -446,3 +446,35 @@ extension SomeClassInActor.ID {
     object.inActor() // expected-error{{'async' in a function that does not support concurrency}}
   }
 }
+
+// ----------------------------------------------------------------------
+// Initializers
+// ----------------------------------------------------------------------
+actor class SomeActorWithInits {
+  var mutableState: Int = 17
+  var otherMutableState: Int
+
+  init() {
+    self.mutableState = 42
+    self.otherMutableState = 17
+
+    self.isolated()
+  }
+
+  func isolated() { }
+}
+
+@MainActor
+class SomeClassWithInits {
+  var mutableState: Int = 17
+  var otherMutableState: Int
+
+  init() {
+    self.mutableState = 42
+    self.otherMutableState = 17
+
+    self.isolated()
+  }
+
+  func isolated() { }
+}

test/Concurrency/concurrent_value_checking.swift

@@ -13,6 +13,18 @@ actor class A1 {
   func asynchronous(_: NotConcurrent?) async { }
 }
 
+actor class A2 {
+  var localVar: NotConcurrent
+
+  init(value: NotConcurrent) {
+    self.localVar = value
+  }
+}
+
+func testActorCreation(value: NotConcurrent) {
+  _ = A2(value: value) // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent' across actors}}
+}
+
 extension A1 {
   func testIsolation(other: A1) async {
     // All within the same actor domain, so the ConcurrentValue restriction
@@ -65,17 +77,29 @@ struct HasSubscript {
   subscript (i: Int) -> NotConcurrent? { nil }
 }
 
+class ClassWithGlobalActorInits {
+  @SomeGlobalActor
+  init(_: NotConcurrent) { }
+
+  @SomeGlobalActor
+  init() { }
+}
+
+
 @MainActor
-func globalTestMain() async {
+func globalTestMain(nc: NotConcurrent) async {
   let a = globalValue // expected-warning{{cannot use let 'globalValue' with a non-concurrent-value type 'NotConcurrent?' across actors}}
   await globalAsync(a) // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent?' across actors}}
   await globalSync(a)  // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent?' across actors}}
+  _ = await ClassWithGlobalActorInits(nc) // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent' across actors}}
+  _ = await ClassWithGlobalActorInits()
 }
 
 @SomeGlobalActor
-func someGlobalTest() {
+func someGlobalTest(nc: NotConcurrent) {
   let hs = HasSubscript()
   let _ = hs[0] // okay
+  _ = ClassWithGlobalActorInits(nc)
 }
 
 // ----------------------------------------------------------------------