[6.1] Revert import access level / attribute filtering

include/swift/AST/Module.h

@@ -1016,6 +1016,11 @@ class ModuleDecl
   /// This assumes that \p module was imported.
   bool isImportedImplementationOnly(const ModuleDecl *module) const;
 
+  /// Returns true if decl context or its content can be serialized by
+  /// cross-module-optimization.
+  /// The \p ctxt can e.g. be a NominalType or the context of a function.
+  bool canBeUsedForCrossModuleOptimization(DeclContext *ctxt) const;
+
   /// Finds all top-level decls of this module.
   ///
   /// This does a simple local lookup, not recursively looking through imports.

lib/AST/Module.cpp

@@ -3010,6 +3010,33 @@ bool ModuleDecl::isImportedImplementationOnly(const ModuleDecl *module) const {
   return true;
 }
 
+bool ModuleDecl::
+canBeUsedForCrossModuleOptimization(DeclContext *ctxt) const {
+  ModuleDecl *moduleOfCtxt = ctxt->getParentModule();
+
+  // If the context defined in the same module - or is the same module, it's
+  // fine.
+  if (moduleOfCtxt == this)
+    return true;
+
+  // See if context is imported in a "regular" way, i.e. not with
+  // @_implementationOnly, `package import` or @_spiOnly.
+  ModuleDecl::ImportFilter filter = {
+    ModuleDecl::ImportFilterKind::ImplementationOnly,
+    ModuleDecl::ImportFilterKind::PackageOnly,
+    ModuleDecl::ImportFilterKind::SPIOnly
+  };
+  SmallVector<ImportedModule, 4> results;
+  getImportedModules(results, filter);
+
+  auto &imports = getASTContext().getImportCache();
+  for (auto &desc : results) {
+    if (imports.isImportedBy(moduleOfCtxt, desc.importedModule))
+      return false;
+  }
+  return true;
+}
+
 void SourceFile::lookupImportedSPIGroups(
                         const ModuleDecl *importedModule,
                         llvm::SmallSetVector<Identifier, 4> &spiGroups) const {

lib/SILOptimizer/IPO/CrossModuleOptimization.cpp

@@ -16,7 +16,6 @@
 
 #define DEBUG_TYPE "cross-module-serialization-setup"
 #include "swift/AST/Module.h"
-#include "swift/AST/ImportCache.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/IRGen/TBDGen.h"
 #include "swift/SIL/ApplySite.h"
@@ -104,11 +103,6 @@ class CrossModuleOptimization {
   bool canSerializeType(CanType type);
   bool canSerializeDecl(NominalTypeDecl *decl);
 
-  /// Check whether decls imported with certain access levels or attributes
-  /// can be serialized.
-  /// The \p ctxt can e.g. be a NominalType or the context of a function.
-  bool checkImports(DeclContext *ctxt) const;
-
   bool canUseFromInline(DeclContext *declCtxt);
 
   bool canUseFromInline(SILFunction *func);
@@ -742,12 +736,7 @@ static bool couldBeLinkedStatically(DeclContext *funcCtxt, SILModule &module) {
   // The stdlib module is always linked dynamically.
   if (funcModule == module.getASTContext().getStdlibModule())
     return false;
-
-  // An sdk or system module should be linked dynamically.
-  if (isPackageCMOEnabled(module.getSwiftModule()) &&
-      funcModule->isNonUserModule())
-    return false;
-
+
   // Conservatively assume the function is in a statically linked module.
   return true;
 }
@@ -757,7 +746,7 @@ bool CrossModuleOptimization::canUseFromInline(DeclContext *declCtxt) {
   if (everything)
     return true;
 
-  if (!checkImports(declCtxt))
+  if (!M.getSwiftModule()->canBeUsedForCrossModuleOptimization(declCtxt))
     return false;
 
   /// If we are emitting a TBD file, the TBD file only contains public symbols
@@ -773,58 +762,6 @@ bool CrossModuleOptimization::canUseFromInline(DeclContext *declCtxt) {
   return true;
 }
 
-bool CrossModuleOptimization::checkImports(DeclContext *ctxt) const {
-  ModuleDecl *moduleOfCtxt = ctxt->getParentModule();
-
-  // If the context defined in the same module - or is the same module, it's
-  // fine.
-  if (moduleOfCtxt == M.getSwiftModule())
-    return true;
-
-  ModuleDecl::ImportFilter filter;
-
-  if (isPackageCMOEnabled(M.getSwiftModule())) {
-    // When Package CMO is enabled, types imported with `package import`
-    // or `@_spiOnly import` into this module should be allowed to be
-    // serialized. These types may be used in APIs with `package` or
-    // higher access level, with or without `@_spi`, and such APIs should
-    // be serializable to allow direct access by another module if it's
-    // in the same package.
-    //
-    // However, types are from modules imported as `@_implementationOnly`
-    // should not be serialized, even if their defining modules are SDK
-    // or system modules. Since these types are intended to remain hidden
-    // from external clients, their metadata (e.g. field offsets) may be
-    // stripped, making it unavailable for look up at runtime. If serialized,
-    // the client will attempt to use the serialized accessor and fail
-    // because the metadata is missing, leading to a linker error.
-    //
-    // This issue applies to transitively imported types as well;
-    // `@_implementationOnly import Foundation` imports `ObjectiveC`
-    // indirectly, and metadata for types like `NSObject` from `ObjectiveC`
-    // can also be stripped, thus such types should not be allowed for
-    // serialization.
-    filter = { ModuleDecl::ImportFilterKind::ImplementationOnly };
-  } else {
-    // See if context is imported in a "regular" way, i.e. not with
-    // @_implementationOnly, `package import` or @_spiOnly.
-    filter = {
-      ModuleDecl::ImportFilterKind::ImplementationOnly,
-      ModuleDecl::ImportFilterKind::PackageOnly,
-      ModuleDecl::ImportFilterKind::SPIOnly
-    };
-  }
-  SmallVector<ImportedModule, 4> results;
-  M.getSwiftModule()->getImportedModules(results, filter);
-
-  auto &imports = M.getSwiftModule()->getASTContext().getImportCache();
-  for (auto &desc : results) {
-    if (imports.isImportedBy(moduleOfCtxt, desc.importedModule))
-      return false;
-  }
-  return true;
-}
-
 /// Returns true if the function \p func can be used from a serialized function.
 bool CrossModuleOptimization::canUseFromInline(SILFunction *function) {
   if (everything)