Implemented suppressing isolated deinit for compatibility with older compiler versions

Author: nickolas-pohilets

include/swift/AST/Decl.h

@@ -1279,6 +1279,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   std::optional<std::pair<CustomAttr *, NominalTypeDecl *>>
   getGlobalActorAttr() const;
 
+  /// Determine whether there is an explicit isolation attribute
+  /// of any kind.
+  bool hasExplicitIsolationAttribute() const;
+
   /// If an alternative module name is specified for this decl, e.g. using
   /// @_originalDefinedIn attribute, this function returns this module name.
   StringRef getAlternateModuleName() const;

include/swift/AST/PrintOptions.h

@@ -37,6 +37,8 @@ class DeclContext;
 class Type;
 class ModuleDecl;
 enum class DeclAttrKind : unsigned;
+class DeclAttribute;
+class CustomAttr;
 class SynthesizedExtensionAnalyzer;
 struct PrintOptions;
 class SILPrintContext;
@@ -342,6 +344,10 @@ struct PrintOptions {
   /// Suppress emitting @available(*, noasync)
   bool SuppressNoAsyncAvailabilityAttr = false;
 
+  /// Suppress emitting isolated or async deinit, and emit open containing class
+  /// as public
+  bool SuppressIsolatedDeinit = false;
+
   /// Whether to print the \c{/*not inherited*/} comment on factory initializers.
   bool PrintFactoryInitializerComment = true;
 
@@ -403,6 +409,8 @@ struct PrintOptions {
       DeclAttrKind::FixedLayout, DeclAttrKind::ShowInInterface,
   };
 
+  std::vector<CustomAttr *> ExcludeCustomAttrList = {};
+
   /// List of attribute kinds that should be printed exclusively.
   /// Empty means allow all.
   std::vector<AnyAttrKind> ExclusiveAttrList;
@@ -648,6 +656,8 @@ struct PrintOptions {
     return false;
   }
 
+  bool excludeAttr(const DeclAttribute *DA) const;
+
   /// Retrieve the set of options for verbose printing to users.
   static PrintOptions printVerbose() {
     PrintOptions result;

include/swift/Basic/Features.def

@@ -401,6 +401,8 @@ EXPERIMENTAL_FEATURE(DebugDescriptionMacro, true)
 
 EXPERIMENTAL_FEATURE(ReinitializeConsumeInMultiBlockDefer, false)
 
+SUPPRESSIBLE_LANGUAGE_FEATURE(IsolatedDeinit, 371, "isolated/async deinit")
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

lib/AST/ASTPrinter.cpp

@@ -180,6 +180,18 @@ static bool shouldPrintAllSemanticDetails(const PrintOptions &options) {
   return false;
 }
 
+bool PrintOptions::excludeAttr(const DeclAttribute *DA) const {
+  if (excludeAttrKind(DA->getKind())) {
+    return true;
+  }
+  if (auto CA = dyn_cast<CustomAttr>(DA)) {
+    if (std::any_of(ExcludeCustomAttrList.begin(), ExcludeCustomAttrList.end(),
+                    [CA](CustomAttr *other) { return other == CA; }))
+      return true;
+  }
+  return false;
+}
+
 PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
                                                    bool preferTypeRepr,
                                                    bool printFullConvention,
@@ -825,7 +837,13 @@ class PrintAST : public ASTVisitor<PrintAST> {
     if (D->getDeclContext()->isLocalContext())
       return;
 
-    printAccess(D->getFormalAccess());
+    if (Options.SuppressIsolatedDeinit &&
+        D->getFormalAccess() == AccessLevel::Open &&
+        usesFeatureIsolatedDeinit(D)) {
+      printAccess(AccessLevel::Public);
+    } else {
+      printAccess(D->getFormalAccess());
+    }
     bool shouldSkipSetterAccess =
         llvm::is_contained(Options.ExcludeAttrList, DeclAttrKind::SetterAccess);
 
@@ -1252,6 +1270,10 @@ void PrintAST::printAttributes(const Decl *D) {
   // Save the current number of exclude attrs to restore once we're done.
   unsigned originalExcludeAttrCount = Options.ExcludeAttrList.size();
 
+  // ExcludeCustomAttrList stores instances of attributes, which are specific
+  // for each decl They cannot be shared across different decls.
+  assert(Options.ExcludeCustomAttrList.empty());
+
   if (Options.PrintImplicitAttrs) {
 
     // Don't print a redundant 'final' if we are printing a 'static' decl.
@@ -1343,9 +1365,19 @@ void PrintAST::printAttributes(const Decl *D) {
     Options.ExcludeAttrList.push_back(DeclAttrKind::Borrowing);
   }
 
+  if (isa<DestructorDecl>(D) && Options.SuppressIsolatedDeinit) {
+    Options.ExcludeAttrList.push_back(DeclAttrKind::Nonisolated);
+    Options.ExcludeAttrList.push_back(DeclAttrKind::Isolated);
+    if (auto globalActor = D->getGlobalActorAttr()) {
+      Options.ExcludeCustomAttrList.push_back(globalActor->first);
+    }
+  }
+  
   attrs.print(Printer, Options, D);
 
+
   Options.ExcludeAttrList.resize(originalExcludeAttrCount);
+  Options.ExcludeCustomAttrList.clear();
 }
 
 void PrintAST::printTypedPattern(const TypedPattern *TP) {
@@ -3206,6 +3238,13 @@ suppressingFeatureBitwiseCopyable2(PrintOptions &options,
   options.ExcludeAttrList.resize(originalExcludeAttrCount);
 }
 
+static void
+suppressingFeatureIsolatedDeinit(PrintOptions &options,
+                                 llvm::function_ref<void()> action) {
+  llvm::SaveAndRestore<bool> scope(options.SuppressIsolatedDeinit, true);
+  action();
+}
+
 /// Suppress the printing of a particular feature.
 static void suppressingFeature(PrintOptions &options, Feature feature,
                                llvm::function_ref<void()> action) {

lib/AST/Attr.cpp

@@ -987,7 +987,7 @@ void DeclAttributes::print(ASTPrinter &Printer, const PrintOptions &Options,
     if (!Options.PrintUserInaccessibleAttrs &&
         DeclAttribute::isUserInaccessible(DA->getKind()))
       continue;
-    if (Options.excludeAttrKind(DA->getKind()))
+    if (Options.excludeAttr(DA))
       continue;
 
     // If we're supposed to suppress expanded macros, check whether this is

lib/AST/Decl.cpp

@@ -985,6 +985,26 @@ std::optional<CustomAttrNominalPair> Decl::getGlobalActorAttr() const {
       ctx.evaluator, GlobalActorAttributeRequest{mutableThis}, std::nullopt);
 }
 
+bool Decl::hasExplicitIsolationAttribute() const {
+  if (auto nonisolatedAttr = getAttrs().getAttribute<NonisolatedAttr>()) {
+    if (!nonisolatedAttr->isImplicit())
+      return true;
+  }
+
+  if (auto isolatedAttr = getAttrs().getAttribute<IsolatedAttr>()) {
+    if (!isolatedAttr->isImplicit()) {
+      return true;
+    }
+  }
+
+  if (auto globalActorAttr = getGlobalActorAttr()) {
+    if (!globalActorAttr->first->isImplicit())
+      return true;
+  }
+
+  return false;
+}
+
 bool Decl::preconcurrency() const {
   if (getAttrs().hasAttribute<PreconcurrencyAttr>())
     return true;

lib/AST/FeatureSet.cpp

@@ -772,6 +772,23 @@ static bool usesFeatureSensitive(Decl *decl) {
 UNINTERESTING_FEATURE(DebugDescriptionMacro)
 UNINTERESTING_FEATURE(ReinitializeConsumeInMultiBlockDefer)
 
+bool swift::usesFeatureIsolatedDeinit(const Decl *decl) {
+  if (auto cd = dyn_cast<ClassDecl>(decl)) {
+    return cd->getFormalAccess() == AccessLevel::Open &&
+           usesFeatureIsolatedDeinit(cd->getDestructor());
+  } else if (auto dd = dyn_cast<DestructorDecl>(decl)) {
+    if (dd->hasExplicitIsolationAttribute()) {
+      return true;
+    }
+    if (auto superDD = dd->getSuperDeinit()) {
+      return usesFeatureIsolatedDeinit(superDD);
+    }
+    return false;
+  } else {
+    return false;
+  }
+}
+
 // ----------------------------------------------------------------------------
 // MARK: - FeatureSet
 // ----------------------------------------------------------------------------

lib/AST/FeatureSet.h

@@ -68,6 +68,8 @@ class FeatureSet {
 /// not part of the enclosing context.
 FeatureSet getUniqueFeaturesUsed(Decl *decl);
 
+bool usesFeatureIsolatedDeinit(const Decl *decl);
+
 } // end namespace swift
 
 #endif /* SWIFT_AST_FEATURES_H */

lib/Sema/TypeCheckConcurrency.cpp

@@ -4378,23 +4378,6 @@ ActorIsolation swift::determineClosureActorIsolation(
   return checker.determineClosureIsolation(closure);
 }
 
-/// Determine whethere there is an explicit isolation attribute
-/// of any kind.
-static bool hasExplicitIsolationAttribute(const Decl *decl) {
-  if (auto nonisolatedAttr =
-      decl->getAttrs().getAttribute<NonisolatedAttr>()) {
-    if (!nonisolatedAttr->isImplicit())
-      return true;
-  }
-
-  if (auto globalActorAttr = decl->getGlobalActorAttr()) {
-    if (!globalActorAttr->first->isImplicit())
-      return true;
-  }
-
-  return false;
-}
-
 /// Determine actor isolation solely from attributes.
 ///
 /// \returns the actor isolation determined from attributes alone (with no
@@ -5797,14 +5780,14 @@ bool swift::contextRequiresStrictConcurrencyChecking(
     } else if (auto decl = dc->getAsDecl()) {
       // If any isolation attributes are present, we're using concurrency
       // features.
-      if (hasExplicitIsolationAttribute(decl))
+      if (decl->hasExplicitIsolationAttribute())
         return true;
 
       // Extensions of explicitly isolated types are using concurrency
       // features.
       if (auto *extension = dyn_cast<ExtensionDecl>(decl)) {
         auto *nominal = extension->getExtendedNominal();
-        if (nominal && hasExplicitIsolationAttribute(nominal) &&
+        if (nominal && nominal->hasExplicitIsolationAttribute() &&
             !getActorIsolation(nominal).preconcurrency())
           return true;
       }
@@ -5817,7 +5800,7 @@ bool swift::contextRequiresStrictConcurrencyChecking(
         // If we're in an accessor declaration, also check the storage
         // declaration.
         if (auto accessor = dyn_cast<AccessorDecl>(decl)) {
-          if (hasExplicitIsolationAttribute(accessor->getStorage()))
+          if (accessor->getStorage()->hasExplicitIsolationAttribute())
             return true;
         }
       }