[Concurrency] Eliminate actor isolation checking for subclasses.

Subclasses inherit the global actor from their superclass by default,
but it's okay to change it---it's just a default that can be
overridden on a per-member basis anyway.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4265,9 +4265,6 @@ ERROR(actor_isolation_multiple_attr,none,
 ERROR(actor_isolation_override_mismatch,none,
       "%0 %1 %2 has different actor isolation from %3 overridden declaration",
       (ActorIsolation, DescriptiveDeclKind, DeclName, ActorIsolation))
-ERROR(actor_isolation_superclass_mismatch,none,
-      "%0 class %1 has different actor isolation from %2 superclass %3",
-      (ActorIsolation, Identifier, ActorIsolation, Identifier))
 
 //------------------------------------------------------------------------------
 // MARK: Type Check Types

lib/Sema/TypeCheckConcurrency.cpp

@@ -1252,31 +1252,3 @@ void swift::checkOverrideActorIsolation(ValueDecl *value) {
       value->getDescriptiveKind(), value->getName(), overriddenIsolation);
   overridden->diagnose(diag::overridden_here);
 }
-
-void swift::checkSubclassActorIsolation(ClassDecl *classDecl) {
-  auto superclassDecl = classDecl->getSuperclassDecl();
-  if (!superclassDecl)
-    return;
-
-  auto isolation = getActorIsolation(classDecl);
-  auto superclassIsolation = getActorIsolation(superclassDecl);
-
-  if (superclassIsolation.requiresSubstitution()) {
-    Type superclassType = classDecl->getSuperclass();
-    if (!superclassType)
-      return;
-
-    SubstitutionMap subs = superclassType->getMemberSubstitutionMap(
-        classDecl->getModuleContext(), classDecl);
-    superclassIsolation = superclassIsolation.subst(subs);
-  }
-
-  if (isolation == superclassIsolation)
-    return;
-
-  // Diagnose mismatch.
-  classDecl->diagnose(
-      diag::actor_isolation_superclass_mismatch, isolation,
-      classDecl->getName(), superclassIsolation, superclassDecl->getName());
-  superclassDecl->diagnose(diag::decl_declared_here, superclassDecl->getName());
-}

lib/Sema/TypeCheckConcurrency.h

@@ -148,9 +148,6 @@ class ActorIsolationRestriction {
 /// overridden declaration.
 void checkOverrideActorIsolation(ValueDecl *value);
 
-/// Check that the actor isolation of a class matches that of its superclass.
-void checkSubclassActorIsolation(ClassDecl *classDecl);
-
 } // end namespace swift
 
 #endif /* SWIFT_SEMA_TYPECHECKCONCURRENCY_H */

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1390,10 +1390,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       (void) VD->isObjC();
       (void) VD->isDynamic();
 
-      // For a class, check actor isolation.
-      if (auto classDecl = dyn_cast<ClassDecl>(VD))
-        checkSubclassActorIsolation(classDecl);
-
       // If this is a member of a nominal type, don't allow it to have a name of
       // "Type" or "Protocol" since we reserve the X.Type and X.Protocol
       // expressions to mean something builtin to the language.  We *do* allow

test/Concurrency/global_actor_inference.swift

@@ -134,13 +134,14 @@ actor class GenericSub<T> : GenericSuper<[T]> {
 }
 
 // ----------------------------------------------------------------------
-// Global actor checking for supeclasses
+// Global actor inference for superclasses
 // ----------------------------------------------------------------------
 struct Container<T> {
-  @GenericGlobalActor<T> class Superclass { } // expected-note{{'Superclass' declared here}}
+  @GenericGlobalActor<T> class Superclass { }
 }
 
 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 { } // expected-error{{global actor 'GenericGlobalActor<U>'-isolated class 'Subclass2' has different actor isolation from global actor 'GenericGlobalActor<[U]>'-isolated superclass 'Superclass'}}
+  @GenericGlobalActor<U> class Subclass2 : Container<[U]>.Superclass { }
 }