Import dealloc method as deinit

Author: nickolas-pohilets

include/swift/AST/PrintOptions.h

@@ -703,7 +703,8 @@ struct PrintOptions {
     result.SkipPrivateStdlibDecls = true;
     result.SkipUnderscoredStdlibProtocols = true;
     result.SkipUnsafeCXXMethods = true;
-    result.SkipDeinit = true;
+    result.SkipDeinit = false; // Deinit may have isolation attributes, which
+                               // are part of the interface
     result.EmptyLineBetweenDecls = true;
     result.CascadeDocComment = true;
     result.ShouldQualifyNestedDeclarations =

lib/ClangImporter/ImportDecl.cpp

@@ -5304,6 +5304,22 @@ namespace {
       result->setHasMissingVTableEntries(false);
       result->setMemberLoader(&Impl, 0);
 
+      // GetDestructorRequest does not trigger lazy member loading
+      // And typechecking may ask for destructor before member loading is
+      // triggered. Create deinit explicitly
+      auto deallocII = &clangCtx.Idents.get("dealloc");
+      auto deallocSelector = clangCtx.Selectors.getNullarySelector(deallocII);
+      auto deallocName = clang::DeclarationName(deallocSelector);
+      for (auto nd : decl->lookup(deallocName)) {
+        if (auto deallocDecl = dyn_cast<clang::ObjCMethodDecl>(nd)) {
+          if (deallocDecl->isInstanceMethod()) {
+            auto loc = Impl.importSourceLoc(deallocDecl->getLocation());
+            auto dtor = Impl.createDeclWithClangNode<DestructorDecl>(
+                deallocDecl, access, loc, result);
+            result->addMember(dtor);
+          }
+        }
+      }
       return result;
     }
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -5082,24 +5082,28 @@ ActorIsolation ActorIsolationRequest::evaluate(
     }
   };
 
+  auto isolationFromAttr = getIsolationFromAttributes(value);
+
   // 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);
-    }
+  if (isa<DestructorDecl>(value)) {
+    if (value->isImplicit() && !isolationFromAttr) {
+      ValueDecl *overriddenValue = value->getOverriddenDeclOrSuperDeinit();
+      ActorIsolation isolation = ActorIsolation::forUnspecified();
+      if (overriddenValue) {
+        isolation = getOverriddenIsolationFor(value);
+      }
 
-    if (hasIsolatedSelf && isolation.isUnspecified()) {
-      // Don't use 'unspecified' for actors, use 'nonisolated' instead
-      // To force generation of the 'nonisolated' attribute in SIL and
-      // .swiftmodule
-      isolation = ActorIsolation::forNonisolated(false);
-    }
+      if (hasIsolatedSelf && isolation.isUnspecified()) {
+        // 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;
+      addAttributesForActorIsolation(isolation);
+      return isolation;
+    }
   }
 
   // If this declaration has actor-isolated "self", it's isolated to that
@@ -5113,7 +5117,9 @@ ActorIsolation ActorIsolationRequest::evaluate(
     if (isa<DestructorDecl>(value) && actor->getName().is("MainActor") &&
         actor->getDeclContext()->isModuleScopeContext() &&
         actor->getDeclContext()->getParentModule()->getABIName().is("Swift")) {
-      return ActorIsolation::forUnspecified();
+      auto isolation = ActorIsolation::forNonisolated(false);
+      addAttributesForActorIsolation(isolation);
+      return isolation;
     }
     return ActorIsolation::forActorInstanceSelf(value);
   }
@@ -5192,7 +5198,6 @@ ActorIsolation ActorIsolationRequest::evaluate(
     return isolation;
   };
 
-  auto isolationFromAttr = getIsolationFromAttributes(value);
   if (isolationFromAttr && isolationFromAttr->preconcurrency() &&
       !value->getAttrs().hasAttribute<PreconcurrencyAttr>()) {
     auto preconcurrency =
@@ -5216,6 +5221,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
       return *mainIsolation;
     }
   }
+
   // If this declaration has one of the actor isolation attributes, report
   // that.
   if (isolationFromAttr) {

test/Concurrency/deinit_isolation.swift

@@ -7,13 +7,16 @@
 // Fixtures
 
 @globalActor final actor FirstActor {
-  static let shared: FirstActor = FirstActor()
+  static let shared = FirstActor()
 }
 
 @globalActor final actor SecondActor {
-  static let shared: SecondActor = SecondActor()
+  static let shared = SecondActor()
 }
 
+@globalActor private final actor PrivateActor {
+  static let shared = PrivateActor()
+}
 
 @FirstActor
 func isolatedFunc() {}  // expected-note 11{{calls to global function 'isolatedFunc()' from outside of its actor context are implicitly asynchronous}}
@@ -432,3 +435,10 @@ class DifferentIsolatedDeinitIsolated2: BaseWithDeinitIsolatedOnSecondActor {
     }
 }
 
+#if !SILGEN
+public class PublicIsolatedOnPrivateActor {
+    // TODO: Both should be producing an error
+    @PrivateActor public func ababahalamaha() {}
+    @PrivateActor deinit {}
+}
+#endif

test/Concurrency/deinit_isolation_import/Inputs/Alpha.framework/Modules/module.modulemap

@@ -0,0 +1,4 @@
+framework module Alpha [system] {
+  header "Alpha-Swift.h"
+  requires objc
+}

test/Concurrency/deinit_isolation_import/Inputs/Alpha.swift

@@ -0,0 +1,7 @@
+import ObjectiveC
+
+@objc open class RoundtripNonisolated: NSObject {}
+
+@objc open class RoundtripIsolated: NSObject {
+    @MainActor deinit {}
+}

test/Concurrency/deinit_isolation_import/Inputs/Beta.framework/Modules/module.modulemap

@@ -0,0 +1,6 @@
+framework module Beta {
+  umbrella header "Beta.h"
+
+  export *
+  module * { export * }
+}

test/Concurrency/deinit_isolation_import/Inputs/Beta.h

@@ -0,0 +1,42 @@
+@import Foundation;
+@import Alpha;
+
+#define MAIN_ACTOR __attribute__((swift_attr("@MainActor")))
+
+@interface BaseNonisolated : NSObject
+@end
+@interface DerivedNonisolated : BaseNonisolated
+@end
+
+MAIN_ACTOR
+@interface BaseIsolatedClass : NSObject
+@end
+@interface DerivedIsolatedClass : BaseIsolatedClass
+@end
+
+@interface BaseIsolatedDealloc : NSObject
+- (void)dealloc MAIN_ACTOR;
+@end
+@interface DerivedIsolatedDealloc : BaseIsolatedDealloc
+@end
+
+@protocol DeallocP
+- (void)dealloc MAIN_ACTOR;
+@end
+
+@interface DeallocIsolatedFromProtocol : NSObject <DeallocP>
+@end
+
+@interface DeallocIsolatedFromCategory : NSObject
+@end
+
+@interface DeallocIsolatedFromCategory (Extra)
+- (void)dealloc MAIN_ACTOR;
+@end
+
+@interface DeallocIsolatedFromExtension : NSObject
+@end
+
+@interface DeallocIsolatedFromExtension ()
+- (void)dealloc MAIN_ACTOR;
+@end