[Concurrency] Substitute into superclass global actors when inheriting them.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -1178,8 +1178,19 @@ ActorIsolation ActorIsolationRequest::evaluate(
   if (auto classDecl = dyn_cast<ClassDecl>(value)) {
     if (auto superclassDecl = classDecl->getSuperclassDecl()) {
       auto superclassIsolation = getActorIsolation(superclassDecl);
-      if (!superclassIsolation.isUnspecified())
+      if (!superclassIsolation.isUnspecified()) {
+        if (superclassIsolation.requiresSubstitution()) {
+          Type superclassType = classDecl->getSuperclass();
+          if (!superclassType)
+            return ActorIsolation::forUnspecified();
+
+          SubstitutionMap subs = superclassType->getMemberSubstitutionMap(
+              classDecl->getModuleContext(), classDecl);
+          superclassIsolation = superclassIsolation.subst(subs);
+        }
+
         return inferredIsolation(superclassIsolation);
+      }
     }
   }
 

test/Concurrency/global_actor_inference.swift

@@ -138,10 +138,20 @@ actor class GenericSub<T> : GenericSuper<[T]> {
 // ----------------------------------------------------------------------
 struct Container<T> {
   @GenericGlobalActor<T> class Superclass { }
+  @GenericGlobalActor<[T]> class Superclass2 { }
 }
 
 struct OtherContainer<U> {
   // Okay to change the global actor in a subclass.
   @GenericGlobalActor<[U]> class Subclass1 : Container<[U]>.Superclass { }
   @GenericGlobalActor<U> class Subclass2 : Container<[U]>.Superclass { }
+
+  // Ensure that substitutions work properly when inheriting.
+  class Subclass3<V> : Container<(U, V)>.Superclass2 {
+    func method() { } // expected-note{{only asynchronous methods can be used outside the actor instance}}
+
+    @OtherGlobalActor func testMethod() {
+      method() // expected-error{{instance method 'method()' isolated to global actor 'GenericGlobalActor<[(U, V)]>' can not be referenced from different global actor 'OtherGlobalActor'}}
+    }
+  }
 }