Merge pull request #64047 from xymus/package-only-imports

xymus · web-flow · commit 644c9437c39c · 2023-03-03T15:14:25.000-08:00
[Serialization] Package imports
diff --git a/include/swift/AST/Module.h b/include/swift/AST/Module.h
@@ -789,13 +789,13 @@ class ModuleDecl
   enum class ImportFilterKind {
     /// Include imports declared with `@_exported`.
     Exported = 1 << 0,
-    /// Include "regular" imports with no special annotation.
+    /// Include "regular" imports with an access-level of `public`.
     Default = 1 << 1,
     /// Include imports declared with `@_implementationOnly` or with an
     /// access-level of `package` or less.
     ImplementationOnly = 1 << 2,
-    /// Include imports of SPIs declared with `@_spi`.
-    SPIAccessControl = 1 << 3,
+    /// Include imports declared with `package import`.
+    PackageOnly = 1 << 3,
     /// Include imports declared with `@_spiOnly`.
     SPIOnly = 1 << 4,
     /// Include imports shadowed by a cross-import overlay. Unshadowed imports
diff --git a/include/swift/Basic/LangOptions.h b/include/swift/Basic/LangOptions.h
@@ -396,6 +396,9 @@ namespace swift {
     /// Access or distribution level of the whole module being parsed.
     LibraryLevel LibraryLevel = LibraryLevel::Other;
 
+    /// The name of the package this module belongs to.
+    std::string PackageName;
+
     /// Warn about cases where Swift 3 would infer @objc but later versions
     /// of Swift do not.
     Swift3ObjCInferenceWarnings WarnSwift3ObjCInference =
diff --git a/include/swift/Frontend/FrontendOptions.h b/include/swift/Frontend/FrontendOptions.h
@@ -64,9 +64,6 @@ class FrontendOptions {
   /// The name of the library to link against when using this module.
   std::string ModuleLinkName;
 
-  /// The name of the package this module belongs to.
-  std::string PackageName;
-
   /// Module name to use when referenced in clients module interfaces.
   std::string ExportAsName;
 
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -5544,7 +5544,6 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     // For the current module, consider both private and public imports.
     ModuleDecl::ImportFilter Filter = ModuleDecl::ImportFilterKind::Exported;
     Filter |= ModuleDecl::ImportFilterKind::Default;
-    Filter |= ModuleDecl::ImportFilterKind::SPIAccessControl;
     SmallVector<ImportedModule, 4> Imports;
     Options.CurrentModule->getImportedModules(Imports, Filter);
 
diff --git a/lib/AST/ImportCache.cpp b/lib/AST/ImportCache.cpp
@@ -195,8 +195,8 @@ ImportSet &ImportCache::getImportSet(const DeclContext *dc) {
     file->getImportedModules(imports,
                              {ModuleDecl::ImportFilterKind::Default,
                               ModuleDecl::ImportFilterKind::ImplementationOnly,
-                              ModuleDecl::ImportFilterKind::SPIOnly,
-                              ModuleDecl::ImportFilterKind::SPIAccessControl});
+                              ModuleDecl::ImportFilterKind::PackageOnly,
+                              ModuleDecl::ImportFilterKind::SPIOnly});
   }
 
   auto &result = getImportSet(ctx, imports);
@@ -280,8 +280,8 @@ ImportCache::getAllAccessPathsNotShadowedBy(const ModuleDecl *mod,
     file->getImportedModules(stack,
                              {ModuleDecl::ImportFilterKind::Default,
                               ModuleDecl::ImportFilterKind::ImplementationOnly,
-                              ModuleDecl::ImportFilterKind::SPIOnly,
-                              ModuleDecl::ImportFilterKind::SPIAccessControl});
+                              ModuleDecl::ImportFilterKind::PackageOnly,
+                              ModuleDecl::ImportFilterKind::SPIOnly});
   }
 
   SmallVector<ImportPath::Access, 4> accessPaths;
diff --git a/lib/AST/Module.cpp b/lib/AST/Module.cpp
@@ -1902,12 +1902,12 @@ SourceFile::getImportedModules(SmallVectorImpl<ImportedModule> &modules,
     if (desc.options.contains(ImportFlags::Exported))
       requiredFilter |= ModuleDecl::ImportFilterKind::Exported;
     else if (desc.options.contains(ImportFlags::ImplementationOnly) ||
-             (desc.accessLevel <= AccessLevel::Package && moduleIsResilient))
+             (desc.accessLevel <= AccessLevel::Internal && moduleIsResilient))
       requiredFilter |= ModuleDecl::ImportFilterKind::ImplementationOnly;
+    else if (desc.accessLevel <= AccessLevel::Package && moduleIsResilient)
+      requiredFilter |= ModuleDecl::ImportFilterKind::PackageOnly;
     else if (desc.options.contains(ImportFlags::SPIOnly))
       requiredFilter |= ModuleDecl::ImportFilterKind::SPIOnly;
-    else if (desc.options.contains(ImportFlags::SPIAccessControl))
-      requiredFilter |= ModuleDecl::ImportFilterKind::SPIAccessControl;
     else
       requiredFilter |= ModuleDecl::ImportFilterKind::Default;
 
@@ -2271,13 +2271,13 @@ SourceFile::collectLinkLibraries(ModuleDecl::LinkLibraryCallback callback) const
 
   ModuleDecl::ImportFilter filter = {
       ModuleDecl::ImportFilterKind::Exported,
-      ModuleDecl::ImportFilterKind::Default,
-      ModuleDecl::ImportFilterKind::SPIAccessControl};
+      ModuleDecl::ImportFilterKind::Default};
 
   auto *topLevel = getParentModule();
 
   ModuleDecl::ImportFilter topLevelFilter = filter;
   topLevelFilter |= ModuleDecl::ImportFilterKind::ImplementationOnly;
+  topLevelFilter |= ModuleDecl::ImportFilterKind::PackageOnly,
   topLevelFilter |= ModuleDecl::ImportFilterKind::SPIOnly;
   topLevel->getImportedModules(stack, topLevelFilter);
 
@@ -2985,7 +2985,8 @@ bool ModuleDecl::isImportedImplementationOnly(const ModuleDecl *module) const {
   ModuleDecl::ImportFilter filter = {
     ModuleDecl::ImportFilterKind::Exported,
     ModuleDecl::ImportFilterKind::Default,
-    ModuleDecl::ImportFilterKind::SPIAccessControl,
+    ModuleDecl::ImportFilterKind::PackageOnly,
+    ModuleDecl::ImportFilterKind::SPIOnly,
     ModuleDecl::ImportFilterKind::ShadowedByCrossImportOverlay};
   SmallVector<ImportedModule, 4> results;
   getImportedModules(results, filter);
@@ -3008,11 +3009,11 @@ canBeUsedForCrossModuleOptimization(DeclContext *ctxt) const {
     return true;
 
   // See if context is imported in a "regular" way, i.e. not with
-  // @_implementationOnly or @_spi.
+  // @_implementationOnly, `package import` or @_spiOnly.
   ModuleDecl::ImportFilter filter = {
     ModuleDecl::ImportFilterKind::ImplementationOnly,
-    ModuleDecl::ImportFilterKind::SPIOnly,
-    ModuleDecl::ImportFilterKind::SPIAccessControl
+    ModuleDecl::ImportFilterKind::PackageOnly,
+    ModuleDecl::ImportFilterKind::SPIOnly
   };
   SmallVector<ImportedModule, 4> results;
   getImportedModules(results, filter);
diff --git a/lib/Frontend/ArgsToFrontendOptionsConverter.cpp b/lib/Frontend/ArgsToFrontendOptionsConverter.cpp
@@ -269,16 +269,6 @@ bool ArgsToFrontendOptionsConverter::convert(
   if (const Arg *A = Args.getLastArg(OPT_module_link_name))
     Opts.ModuleLinkName = A->getValue();
 
-  if (const Arg *A = Args.getLastArg(OPT_package_name)) {
-    auto pkgName = A->getValue();
-    if (!Lexer::isIdentifier(pkgName))
-      Diags.diagnose(SourceLoc(), diag::error_bad_package_name, pkgName);
-    else if (pkgName == STDLIB_NAME)
-      Diags.diagnose(SourceLoc(), diag::error_stdlib_package_name, pkgName);
-    else
-      Opts.PackageName = pkgName;
-  }
-
   if (const Arg *A = Args.getLastArg(OPT_export_as)) {
     auto exportAs = A->getValue();
     if (!Lexer::isIdentifier(exportAs))
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
@@ -739,6 +739,16 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     }
   }
 
+  if (const Arg *A = Args.getLastArg(OPT_package_name)) {
+    auto pkgName = A->getValue();
+    if (!Lexer::isIdentifier(pkgName))
+      Diags.diagnose(SourceLoc(), diag::error_bad_package_name, pkgName);
+    else if (pkgName == STDLIB_NAME)
+      Diags.diagnose(SourceLoc(), diag::error_stdlib_package_name, pkgName);
+    else
+      Opts.PackageName = pkgName;
+  }
+
   if (const Arg *A = Args.getLastArg(OPT_require_explicit_availability_EQ)) {
     StringRef diagLevel = A->getValue();
     if (diagLevel == "warn") {
diff --git a/lib/Frontend/Frontend.cpp b/lib/Frontend/Frontend.cpp
@@ -1088,9 +1088,9 @@ ModuleDecl *CompilerInstance::getMainModule() const {
       MainModule->setABIName(getASTContext().getIdentifier(
           Invocation.getFrontendOptions().ModuleABIName));
     }
-    if (!Invocation.getFrontendOptions().PackageName.empty()) {
+    if (!Invocation.getLangOptions().PackageName.empty()) {
       MainModule->setPackageName(getASTContext().getIdentifier(
-          Invocation.getFrontendOptions().PackageName));
+          Invocation.getLangOptions().PackageName));
     }
     if (!Invocation.getFrontendOptions().ExportAsName.empty()) {
       MainModule->setExportAsName(getASTContext().getIdentifier(
diff --git a/lib/Frontend/ModuleInterfaceSupport.cpp b/lib/Frontend/ModuleInterfaceSupport.cpp
@@ -70,8 +70,7 @@ static void printToolVersionAndFlagsComment(raw_ostream &out,
            moduleName << "=" << moduleName;
 
     ModuleDecl::ImportFilter filter = {ModuleDecl::ImportFilterKind::Default,
-                           ModuleDecl::ImportFilterKind::Exported,
-                           ModuleDecl::ImportFilterKind::SPIAccessControl};
+                                       ModuleDecl::ImportFilterKind::Exported};
     if (Opts.PrintPrivateInterfaceContent)
       filter |= ModuleDecl::ImportFilterKind::SPIOnly;
 
@@ -228,8 +227,7 @@ static void printImports(raw_ostream &out,
   // it's not obvious what higher-level optimization would be factored out here.
   ModuleDecl::ImportFilter allImportFilter = {
       ModuleDecl::ImportFilterKind::Exported,
-      ModuleDecl::ImportFilterKind::Default,
-      ModuleDecl::ImportFilterKind::SPIAccessControl};
+      ModuleDecl::ImportFilterKind::Default};
 
   // With -experimental-spi-imports:
   // When printing the private swiftinterface file, print implementation-only
diff --git a/lib/FrontendTool/ImportedModules.cpp b/lib/FrontendTool/ImportedModules.cpp
@@ -86,7 +86,8 @@ bool swift::emitImportedModules(ModuleDecl *mainModule,
           imported, {ModuleDecl::ImportFilterKind::Exported,
                      ModuleDecl::ImportFilterKind::Default,
                      ModuleDecl::ImportFilterKind::ImplementationOnly,
-                     ModuleDecl::ImportFilterKind::SPIAccessControl});
+                     ModuleDecl::ImportFilterKind::PackageOnly,
+                     ModuleDecl::ImportFilterKind::SPIOnly});
 
       for (auto IM : imported) {
         if (auto clangModule = IM.importedModule->findUnderlyingClangModule())
diff --git a/lib/FrontendTool/LoadedModuleTrace.cpp b/lib/FrontendTool/LoadedModuleTrace.cpp
@@ -113,7 +113,8 @@ static void getImmediateImports(
         ModuleDecl::ImportFilterKind::Exported,
         ModuleDecl::ImportFilterKind::Default,
         ModuleDecl::ImportFilterKind::ImplementationOnly,
-        ModuleDecl::ImportFilterKind::SPIAccessControl,
+        ModuleDecl::ImportFilterKind::PackageOnly,
+        ModuleDecl::ImportFilterKind::SPIOnly,
         ModuleDecl::ImportFilterKind::ShadowedByCrossImportOverlay}) {
   SmallVector<ImportedModule, 8> importList;
   module->getImportedModules(importList, importFilter);
diff --git a/lib/IDE/CodeCompletion.cpp b/lib/IDE/CodeCompletion.cpp
@@ -1388,7 +1388,8 @@ void swift::ide::deliverCompletionResults(
                        ModuleDecl::ImportFilterKind::Exported,
                        ModuleDecl::ImportFilterKind::Default,
                        ModuleDecl::ImportFilterKind::ImplementationOnly,
-                       ModuleDecl::ImportFilterKind::SPIAccessControl,
+                       ModuleDecl::ImportFilterKind::PackageOnly,
+                       ModuleDecl::ImportFilterKind::SPIOnly,
                    });
 
       for (auto Imported : Imports) {
diff --git a/lib/Sema/TypeCheckAccess.cpp b/lib/Sema/TypeCheckAccess.cpp
@@ -1810,7 +1810,6 @@ swift::getDisallowedOriginKind(const Decl *decl,
     auto filter = ModuleDecl::ImportFilter(
         {ModuleDecl::ImportFilterKind::Exported,
          ModuleDecl::ImportFilterKind::Default,
-         ModuleDecl::ImportFilterKind::SPIAccessControl,
          ModuleDecl::ImportFilterKind::ShadowedByCrossImportOverlay});
     SmallVector<ImportedModule, 4> sfImportedModules;
     SF->getImportedModules(sfImportedModules, filter);
diff --git a/lib/Serialization/ModuleFile.cpp b/lib/Serialization/ModuleFile.cpp
@@ -209,6 +209,10 @@ Status ModuleFile::associateWithFileContext(FileUnit *file, SourceLoc diagLoc,
       continue;
     }
 
+    if (dependency.isPackageOnly() &&
+        ctx.LangOpts.PackageName != this->getModulePackageName())
+      continue;
+
     ImportPath::Builder builder(ctx, dependency.Core.RawPath,
                                 /*separator=*/'\0');
     for (const auto &elem : builder) {
diff --git a/lib/Serialization/ModuleFile.h b/lib/Serialization/ModuleFile.h
@@ -107,6 +107,9 @@ class ModuleFile
     bool isImplementationOnly() const {
       return Core.isImplementationOnly();
     }
+    bool isPackageOnly() const {
+      return Core.isPackageOnly();
+    }
 
     bool isHeader() const { return Core.isHeader(); }
     bool isScoped() const { return Core.isScoped(); }
diff --git a/lib/Serialization/ModuleFileSharedCore.cpp b/lib/Serialization/ModuleFileSharedCore.cpp
@@ -1021,6 +1021,8 @@ getActualImportControl(unsigned rawValue) {
     return ModuleDecl::ImportFilterKind::Exported;
   case static_cast<unsigned>(serialization::ImportControl::ImplementationOnly):
     return ModuleDecl::ImportFilterKind::ImplementationOnly;
+  case static_cast<unsigned>(serialization::ImportControl::PackageOnly):
+    return ModuleDecl::ImportFilterKind::PackageOnly;
   default:
     return None;
   }
diff --git a/lib/Serialization/ModuleFileSharedCore.h b/lib/Serialization/ModuleFileSharedCore.h
@@ -150,6 +150,9 @@ class ModuleFileSharedCore {
     bool isImplementationOnly() const {
       return getImportControl() == ImportFilterKind::ImplementationOnly;
     }
+    bool isPackageOnly() const {
+      return getImportControl() == ImportFilterKind::PackageOnly;
+    }
 
     bool isHeader() const { return IsHeader; }
     bool isScoped() const { return IsScoped; }
@@ -557,6 +560,10 @@ class ModuleFileSharedCore {
     return Name;
   }
 
+  StringRef getModulePackageName() const {
+    return ModulePackageName;
+  }
+
   /// Returns the list of modules this module depends on.
   ArrayRef<Dependency> getDependencies() const {
     return Dependencies;
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 750; // serialize param specifiers into ParamTypeFlags
+const uint16_t SWIFTMODULE_VERSION_MINOR = 751; // package only import
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -584,7 +584,9 @@ enum class ImportControl : uint8_t {
   /// `@_exported import FooKit`
   Exported,
   /// `@_uncheckedImplementationOnly import FooKit`
-  ImplementationOnly
+  ImplementationOnly,
+  /// `package import FooKit`
+  PackageOnly
 };
 using ImportControlField = BCFixed<2>;
 
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
@@ -1215,7 +1215,7 @@ void Serializer::writeInputBlock(const SerializationOptions &options) {
                         {ModuleDecl::ImportFilterKind::Exported,
                          ModuleDecl::ImportFilterKind::Default,
                          ModuleDecl::ImportFilterKind::ImplementationOnly,
-                         ModuleDecl::ImportFilterKind::SPIAccessControl});
+                         ModuleDecl::ImportFilterKind::PackageOnly});
   ImportedModule::removeDuplicates(allImports);
 
   // Collect the public and private imports as a subset so that we can
@@ -1224,8 +1224,8 @@ void Serializer::writeInputBlock(const SerializationOptions &options) {
       getImportsAsSet(M, ModuleDecl::ImportFilterKind::Exported);
   ImportSet privateImportSet =
       getImportsAsSet(M, ModuleDecl::ImportFilterKind::Default);
-  ImportSet spiImportSet =
-      getImportsAsSet(M, ModuleDecl::ImportFilterKind::SPIAccessControl);
+  ImportSet packageOnlyImportSet =
+      getImportsAsSet(M, ModuleDecl::ImportFilterKind::PackageOnly);
 
   auto clangImporter =
     static_cast<ClangImporter *>(M->getASTContext().getClangModuleLoader());
@@ -1271,8 +1271,10 @@ void Serializer::writeInputBlock(const SerializationOptions &options) {
     // form here.
     if (publicImportSet.count(import))
       stableImportControl = ImportControl::Exported;
-    else if (privateImportSet.count(import) || spiImportSet.count(import))
+    else if (privateImportSet.count(import))
       stableImportControl = ImportControl::Normal;
+    else if (packageOnlyImportSet.count(import))
+      stableImportControl = ImportControl::PackageOnly;
     else
       stableImportControl = ImportControl::ImplementationOnly;
 
diff --git a/lib/Serialization/SerializedModuleLoader.cpp b/lib/Serialization/SerializedModuleLoader.cpp
@@ -426,6 +426,10 @@ llvm::ErrorOr<ModuleDependencyInfo> SerializedModuleLoaderBase::scanModuleFile(
     if (dependency.isImplementationOnly())
       continue;
 
+    if (dependency.isPackageOnly() &&
+        Ctx.LangOpts.PackageName != loadedModuleFile->getModulePackageName())
+      continue;
+
     // Find the top-level module name.
     auto modulePathStr = dependency.getPrettyPrintedPath();
     StringRef moduleName = modulePathStr;
diff --git a/test/Sema/package-only-references.swift b/test/Sema/package-only-references.swift
@@ -0,0 +1,56 @@
+/// Simple use case of a package only import.
+
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+/// Build the libraries.
+// RUN: %target-swift-frontend -emit-module %t/PackageImportedLib.swift -o %t \
+// RUN:   -swift-version 5 -enable-library-evolution \
+// RUN:   -enable-experimental-feature AccessLevelOnImport
+// RUN: %target-swift-frontend -emit-module %t/PackageLib.swift -o %t \
+// RUN:   -swift-version 5 -enable-library-evolution -I %t \
+// RUN:   -enable-experimental-feature AccessLevelOnImport \
+// RUN:   -package-name MyPackage
+
+/// A client in the same package builds fine.
+// RUN: %target-swift-frontend -typecheck %t/Client.swift -I %t \
+// RUN:   -package-name MyPackage -I %t \
+// RUN:   -enable-experimental-feature AccessLevelOnImport
+
+/// A client outside of the package raises errors.
+// RUN: %target-swift-frontend -typecheck %t/Client.swift -I %t \
+// RUN:   -package-name NotMyPackage -I %t \
+// RUN:   -enable-experimental-feature AccessLevelOnImport -verify
+
+//--- PackageImportedLib.swift
+public struct IndirectType {
+    public init() {}
+    public func someMethod() {}
+}
+public protocol IndirectProtocol {}
+
+//--- PackageLib.swift
+package import PackageImportedLib
+
+package func getIndirectType() -> IndirectType {
+    return IndirectType()
+}
+
+package func packageFunc(a: IndirectType) {
+}
+
+package struct PackageStruct : IndirectProtocol {
+    package init() {}
+
+    package var a = IndirectType()
+}
+
+//--- Client.swift
+public import PackageLib
+
+let t = getIndirectType() // expected-error {{cannot find 'getIndirectType' in scope}}
+t.someMethod()
+packageFunc(a: t) // expected-error {{cannot find 'packageFunc' in scope}}
+
+let s = PackageStruct() // expected-error {{cannot find 'PackageStruct' in scope}}
+s.a.someMethod()
diff --git a/test/Serialization/access-level-import-dependencies.swift b/test/Serialization/access-level-import-dependencies.swift
diff --git a/test/Serialization/package-dependencies.swift b/test/Serialization/package-dependencies.swift

Original file line number	Diff line number	Diff line change
`@@ -1088,9 +1088,9 @@ ModuleDecl *CompilerInstance::getMainModule() const {`
`1088`	`1088`	`MainModule->setABIName(getASTContext().getIdentifier(`
`1089`	`1089`	`Invocation.getFrontendOptions().ModuleABIName));`
`1090`	`1090`	`}`
`1091`		`- if (!Invocation.getFrontendOptions().PackageName.empty()) {`
	`1091`	`+ if (!Invocation.getLangOptions().PackageName.empty()) {`
`1092`	`1092`	`MainModule->setPackageName(getASTContext().getIdentifier(`
`1093`		`- Invocation.getFrontendOptions().PackageName));`
	`1093`	`+ Invocation.getLangOptions().PackageName));`
`1094`	`1094`	`}`
`1095`	`1095`	`if (!Invocation.getFrontendOptions().ExportAsName.empty()) {`
`1096`	`1096`	`MainModule->setExportAsName(getASTContext().getIdentifier(`