Propagate "unsafe" global actors more freely.

Propagate "unsafe" global actors in the same manner as "safe" global
actors. This propagates global actors much further (especially from
classes and protocols), allowing more code to implicitly be known to be
running on the given global actor.

Fixes rdar://75548170.

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
   }