Added more tests. Implemented logic for inferring actor isolation for deinit from base class and skipping isolation when deinit is implicit.

Author: nickolas-pohilets

lib/Sema/TypeCheckConcurrency.cpp

@@ -5044,9 +5044,65 @@ ActorIsolation ActorIsolationRequest::evaluate(
     Evaluator &evaluator, ValueDecl *value) const {
   auto &ctx = value->getASTContext();
 
+  const bool hasIsolatedSelf =
+      evaluateOrDefault(evaluator, HasIsolatedSelfRequest{value}, false);
+
+  auto addAttributesForActorIsolation = [&](ActorIsolation isolation) {
+    ASTContext &ctx = value->getASTContext();
+    switch (isolation) {
+    case ActorIsolation::Nonisolated:
+    case ActorIsolation::NonisolatedUnsafe: {
+      value->getAttrs().add(new (ctx) NonisolatedAttr(
+          isolation == ActorIsolation::NonisolatedUnsafe, /*implicit=*/true));
+      break;
+    }
+    case ActorIsolation::GlobalActor: {
+      auto typeExpr = TypeExpr::createImplicit(isolation.getGlobalActor(), ctx);
+      auto attr = CustomAttr::create(ctx, SourceLoc(), typeExpr, /*implicit=*/true);
+      value->getAttrs().add(attr);
+
+      if (isolation.preconcurrency() && !value->getAttrs().hasAttribute<PreconcurrencyAttr>()) {
+        auto preconcurrency = new (ctx) PreconcurrencyAttr(/*isImplicit*/true);
+        value->getAttrs().add(preconcurrency);
+      }
+      break;
+    }
+    case ActorIsolation::Erased:
+      llvm_unreachable("cannot add attributes for erased isolation");
+    case ActorIsolation::ActorInstance: {
+      // Nothing to do. Default value for actors.
+      assert(hasIsolatedSelf);
+      break;
+    }
+    case ActorIsolation::Unspecified: {
+      // Nothing to do. Default value for non-actors.
+      assert(!hasIsolatedSelf);
+      break;
+    }
+    }
+  };
+
+  // No need to isolate implicit deinit, unless there is already an isolated one
+  // in the superclass
+  if (value->isImplicit() && isa<DestructorDecl>(value)) {
+    ValueDecl *overriddenValue = value->getOverriddenDeclOrSuperDeinit();
+    ActorIsolation isolation = ActorIsolation::forUnspecified();
+    if (overriddenValue) {
+      isolation = getOverriddenIsolationFor(value);
+    } else if (hasIsolatedSelf) {
+      // Don't use 'unspecified' for actors, use 'nonisolated' instead
+      // To force generation of the 'nonisolated' attribute in SIL and
+      // .swiftmodule
+      isolation = ActorIsolation::forNonisolated(false);
+    }
+
+    addAttributesForActorIsolation(isolation);
+    return isolation;
+  }
+
   // If this declaration has actor-isolated "self", it's isolated to that
   // actor.
-  if (evaluateOrDefault(evaluator, HasIsolatedSelfRequest{value}, false)) {
+  if (hasIsolatedSelf) {
     auto actor = value->getDeclContext()->getSelfNominalTypeDecl();
     assert(actor && "could not find the actor that 'self' is isolated to");
 
@@ -5190,7 +5246,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
 
   // Look for and remember the overridden declaration's isolation.
   std::optional<ActorIsolation> overriddenIso;
-  ValueDecl *overriddenValue = value->getOverriddenDecl();
+  ValueDecl *overriddenValue = value->getOverriddenDeclOrSuperDeinit();
   if (overriddenValue) {
     // use the overridden decl's iso as the default isolation for this decl.
     defaultIsolation = getOverriddenIsolationFor(value);
@@ -5236,27 +5292,15 @@ ActorIsolation ActorIsolationRequest::evaluate(
               inferred.preconcurrency());
         }
 
-        value->getAttrs().add(new (ctx) NonisolatedAttr(
-            inferred == ActorIsolation::NonisolatedUnsafe, /*implicit=*/true));
+        // Add nonisolated attribute
+        addAttributesForActorIsolation(inferred);
         break;
 
       case ActorIsolation::Erased:
         llvm_unreachable("cannot infer erased isolation");
-
       case ActorIsolation::GlobalActor: {
-        auto typeExpr =
-            TypeExpr::createImplicit(inferred.getGlobalActor(), ctx);
-        auto attr =
-            CustomAttr::create(ctx, SourceLoc(), typeExpr, /*implicit=*/true);
-        value->getAttrs().add(attr);
-
-        if (inferred.preconcurrency() &&
-            !value->getAttrs().hasAttribute<PreconcurrencyAttr>()) {
-          auto preconcurrency =
-              new (ctx) PreconcurrencyAttr(/*isImplicit*/true);
-          value->getAttrs().add(preconcurrency);
-        }
-
+        // Add global actor attribute
+        addAttributesForActorIsolation(inferred);
         break;
       }