Merge pull request #36548 from DougGregor/global-actor-unsafe-propagation

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -2383,11 +2383,11 @@ static Optional<ActorIsolation> getIsolationFromAttributes(
     }
   }
 
-    // If the declaration is explicitly marked 'nonisolated', report it as
-    // independent.
-    if (nonisolatedAttr) {
-      return ActorIsolation::forIndependent(ActorIndependentKind::Safe);
-    }
+  // If the declaration is explicitly marked 'nonisolated', report it as
+  // independent.
+  if (nonisolatedAttr) {
+    return ActorIsolation::forIndependent(ActorIndependentKind::Safe);
+  }
 
   // If the declaration is explicitly marked @actorIndependent, report it as
   // independent.
@@ -2562,8 +2562,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
   }
 
   // Function used when returning an inferred isolation.
-  auto inferredIsolation = [&](
-      ActorIsolation inferred, bool propagateUnsafe = false) {
+  auto inferredIsolation = [&](ActorIsolation inferred) {
     // Add an implicit attribute to capture the actor isolation that was
     // inferred, so that (e.g.) it will be printed and serialized.
     ASTContext &ctx = value->getASTContext();
@@ -2576,13 +2575,6 @@ ActorIsolation ActorIsolationRequest::evaluate(
       break;
 
     case ActorIsolation::GlobalActorUnsafe:
-      if (!propagateUnsafe && !value->hasClangNode()) {
-        // Don't infer unsafe global actor isolation.
-        return ActorIsolation::forUnspecified();
-      }
-
-      LLVM_FALLTHROUGH;
-
     case ActorIsolation::GlobalActor: {
       auto typeExpr = TypeExpr::createImplicit(inferred.getGlobalActor(), ctx);
       auto attr = CustomAttr::create(
@@ -2631,7 +2623,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
     if (auto wrapperInfo = var->getAttachedPropertyWrapperTypeInfo(0)) {
       if (auto wrappedValue = wrapperInfo.valueVar) {
         if (auto isolation = getActorIsolation(wrappedValue))
-          return inferredIsolation(isolation, /*propagateUnsafe=*/true);
+          return inferredIsolation(isolation);
       }
     }
 
@@ -2645,7 +2637,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
           if (!isa<ClassDecl>(backingNominal) ||
               !cast<ClassDecl>(backingNominal)->isActor()) {
             if (auto isolation = getActorIsolation(backingNominal))
-              return inferredIsolation(isolation, /*propagateUnsafe=*/true);
+              return inferredIsolation(isolation);
           }
         }
       }
@@ -2659,7 +2651,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
               originalVar->getAttachedPropertyWrapperTypeInfo(0)) {
         if (auto projectedValue = wrapperInfo.projectedValueVar) {
           if (auto isolation = getActorIsolation(projectedValue))
-            return inferredIsolation(isolation, /*propagateUnsafe=*/true);
+            return inferredIsolation(isolation);
         }
       }
     }
@@ -2669,8 +2661,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
     // If the declaration witnesses a protocol requirement that is isolated,
     // use that.
     if (auto witnessedIsolation = getIsolationFromWitnessedRequirements(value)) {
-      if (auto inferred = inferredIsolation(
-              *witnessedIsolation, /*propagateUnsafe=*/defaultIsolation))
+      if (auto inferred = inferredIsolation(*witnessedIsolation))
         return inferred;
     }
 
@@ -2710,10 +2701,8 @@ ActorIsolation ActorIsolationRequest::evaluate(
     // If the declaration is in a nominal type (or extension thereof) that
     // has isolation, use that.
     if (auto selfTypeDecl = value->getDeclContext()->getSelfNominalTypeDecl()) {
-      auto selfTypeIsolation = getActorIsolation(selfTypeDecl);
-      if (!selfTypeIsolation.isUnspecified()) {
+      if (auto selfTypeIsolation = getActorIsolation(selfTypeDecl))
         return inferredIsolation(selfTypeIsolation);
-      }
     }
   }
 

test/Concurrency/actor_isolation_unsafe.swift

@@ -33,6 +33,31 @@ struct S4_P1: P1 {
   @SomeGlobalActor func onMainActor() { } // expected-error{{instance method 'onMainActor()' isolated to global actor 'SomeGlobalActor' can not satisfy corresponding requirement from protocol 'P1' isolated to global actor 'MainActor'}}
 }
 
+@MainActor(unsafe)
+protocol P2 {
+  func f() // expected-note{{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+  @actorIndependent func g()
+}
+
+struct S5_P2: P2 {
+  func f() { } // expected-note{{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+  func g() { }
+}
+
+@actorIndependent func testP2(x: S5_P2, p2: P2) {
+  p2.f() // expected-error{{instance method 'f()' isolated to global actor 'MainActor' can not be referenced from a non-isolated synchronous context}}
+  p2.g() // OKAY
+  x.f() // expected-error{{'f()' isolated to global actor 'MainActor' can not be referenced from a non-isolated synchronous context}}
+  x.g() // OKAY
+}
+
+func testP2_noconcurrency(x: S5_P2, p2: P2) {
+  p2.f() // okay, not concurrency-related code
+  p2.g() // okay
+  x.f() // okay, not concurrency-related code
+  x.g() // OKAY
+}
+
 // ----------------------------------------------------------------------
 // Overriding and unsafe global actor
 // ----------------------------------------------------------------------
@@ -41,7 +66,7 @@ class C1 {
 }
 
 class C2: C1 {
-  override func method() { // expected-note{{overridden declaration is here}}
+  override func method() { // expected-note 2{{overridden declaration is here}}
     globalSome() // okay
   }
 }
@@ -65,14 +90,12 @@ class C5: C1 {
 
 class C6: C2 {
   // We didn't infer any actor isolation for C2.method().
-  @SomeGlobalActor override func method() { // expected-error{{global actor 'SomeGlobalActor'-isolated instance method 'method()' has different actor isolation from non-actor-isolated overridden declaration}}
+  @SomeGlobalActor override func method() { // expected-error{{global actor 'SomeGlobalActor'-isolated instance method 'method()' has different actor isolation from global actor 'MainActor'-isolated overridden declaration}}
   }
 }
 
 class C7: C2 {
-  // We didn't infer any actor isolation for C2.method(), but it's okay to be
-  // explicitly unsafe.
-  @SomeGlobalActor(unsafe) override func method() {
+  @SomeGlobalActor(unsafe) override func method() { // expected-error{{global actor 'SomeGlobalActor'-isolated instance method 'method()' has different actor isolation from global actor 'MainActor'-isolated overridden declaration}}
     globalMain() // expected-error{{global function 'globalMain()' isolated to global actor 'MainActor' can not be referenced from different global actor 'SomeGlobalActor'}}
     globalSome() // okay
   }