Reject isolation attributes on deinit in value types

Author: nickolas-pohilets

include/swift/AST/DiagnosticsSema.def

@@ -5939,6 +5939,9 @@ ERROR(async_unavailable_decl,none,
 ERROR(isolated_deinit_no_isolation,none,
       "deinit is marked isolated, but containing class %0 is not isolated to an actor",
       (DeclName))
+ERROR(isolated_deinit_on_value_type,none,
+      "only classes and actors can have isolated deinit",
+      ())
 
 //------------------------------------------------------------------------------
 // MARK: String Processing

lib/Sema/TypeCheckAttr.cpp

@@ -109,6 +109,18 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
     return true;
   }
 
+  void diagnoseIsolatedDeinitInValueTypes(DeclAttribute *attr) {
+    if (isa<DestructorDecl>(D)) {
+      if (auto nominal = dyn_cast<NominalTypeDecl>(D->getDeclContext())) {
+        if (!isa<ClassDecl>(nominal)) {
+          // only classes and actors can have isolated deinit.
+          diagnoseAndRemoveAttr(attr, diag::isolated_deinit_on_value_type);
+          return;
+        }
+      }
+    }
+  }
+
   template <typename... ArgTypes>
   InFlightDiagnostic diagnose(ArgTypes &&... Args) const {
     return Ctx.Diags.diagnose(std::forward<ArgTypes>(Args)...);
@@ -130,7 +142,6 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   IGNORED_ATTR(HasMissingDesignatedInitializers)
   IGNORED_ATTR(InheritsConvenienceInitializers)
   IGNORED_ATTR(Inline)
-  IGNORED_ATTR(Isolated)
   IGNORED_ATTR(ObjCBridged)
   IGNORED_ATTR(ObjCNonLazyRealization)
   IGNORED_ATTR(ObjCRuntimeName)
@@ -330,6 +341,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
 
   void visitReasyncAttr(ReasyncAttr *attr);
   void visitNonisolatedAttr(NonisolatedAttr *attr);
+  void visitIsolatedAttr(IsolatedAttr *attr);
 
   void visitNoImplicitCopyAttr(NoImplicitCopyAttr *attr);
 
@@ -4211,6 +4223,7 @@ void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
   // If the nominal type is a global actor, let the global actor attribute
   // retrieval request perform checking for us.
   if (nominal->isGlobalActor()) {
+    diagnoseIsolatedDeinitInValueTypes(attr);
     (void)D->getGlobalActorAttr();
     if (auto value = dyn_cast<ValueDecl>(D)) {
       (void)getActorIsolation(value);
@@ -7127,11 +7140,17 @@ void AttributeChecker::visitNonisolatedAttr(NonisolatedAttr *attr) {
     }
   }
 
+  diagnoseIsolatedDeinitInValueTypes(attr);
+
   if (auto VD = dyn_cast<ValueDecl>(D)) {
     (void)getActorIsolation(VD);
   }
 }
 
+void AttributeChecker::visitIsolatedAttr(IsolatedAttr *attr) {
+  diagnoseIsolatedDeinitInValueTypes(attr);
+}
+
 void AttributeChecker::visitGlobalActorAttr(GlobalActorAttr *attr) {
   auto nominal = dyn_cast<NominalTypeDecl>(D);
   if (!nominal)
@@ -7146,6 +7165,8 @@ void AttributeChecker::visitGlobalActorAttr(GlobalActorAttr *attr) {
     return;
   }
 
+  diagnoseIsolatedDeinitInValueTypes(attr);
+
   (void)nominal->isGlobalActor();
 }
 

test/Concurrency/deinit_isolation_in_value_types.swift

@@ -0,0 +1,56 @@
+// RUN: %target-swift-frontend -disable-availability-checking -parse-as-library -emit-silgen -verify %s
+
+@globalActor final actor FirstActor {
+  static let shared = FirstActor()
+}
+
+struct AS: ~Copyable {
+  @FirstActor deinit {} // expected-error {{only classes and actors can have isolated deinit}}
+}
+
+@FirstActor
+struct BS: ~Copyable {
+  isolated deinit {} // expected-error {{only classes and actors can have isolated deinit}}
+}
+
+struct CS: ~Copyable {
+  isolated deinit {} // expected-error {{only classes and actors can have isolated deinit}}
+}
+
+struct DS: ~Copyable {
+  nonisolated deinit {} // expected-error {{only classes and actors can have isolated deinit}}
+}
+
+struct ES: ~Copyable {
+  @FirstActor isolated deinit {} // expected-error 2 {{only classes and actors can have isolated deinit}}
+}
+
+enum AE: ~Copyable {
+  // expected-error@+1 {{deinitializers are not yet supported on noncopyable enums}}
+  @FirstActor deinit {} // expected-error {{only classes and actors can have isolated deinit}}
+}
+
+@FirstActor
+enum BE: ~Copyable {
+  case dummy
+  // expected-error@+1 {{deinitializers are not yet supported on noncopyable enums}}
+  isolated deinit {} // expected-error {{only classes and actors can have isolated deinit}}
+}
+
+enum CE: ~Copyable {
+  case dummy
+  // expected-error@+1 {{deinitializers are not yet supported on noncopyable enums}}
+  isolated deinit {} // expected-error {{only classes and actors can have isolated deinit}}
+}
+
+enum DE: ~Copyable {
+  case dummy
+  // expected-error@+1 {{deinitializers are not yet supported on noncopyable enums}}
+  nonisolated deinit {} // expected-error {{only classes and actors can have isolated deinit}}
+}
+
+enum EE: ~Copyable {
+  case dummy
+  // expected-error@+1 {{deinitializers are not yet supported on noncopyable enums}}
+  @FirstActor isolated deinit {} // expected-error 2 {{only classes and actors can have isolated deinit}}
+}