Introduce a package interface.

It has an extension .package.swiftinterface and contains package decls
as well as SPIs and public/inlinable decls. When a module is loaded
from interface, it now looks up the package-name in the interface
and checks if the importer is in the same package. If so, it uses
that package interface found to load the module. If not, uses the existing
logic to load modules.

Resolves rdar://104617854

Author: elsh

include/swift/AST/PrintOptions.h

@@ -118,6 +118,12 @@ struct ShouldPrintChecker {
   virtual ~ShouldPrintChecker() = default;
 };
 
+enum class PrintInterfaceContentMode : uint8_t {
+  Public, // prints public/inlinable decls
+  Private, // prints SPI and public/inlinable decls
+  Package // prints package, SPI, and public/inlinable decls
+};
+
 /// Options for printing AST nodes.
 ///
 /// A default-constructed PrintOptions is suitable for printing to users;
@@ -299,8 +305,7 @@ struct PrintOptions {
   /// Whether to skip keywords with a prefix of underscore such as __consuming.
   bool SkipUnderscoredKeywords = false;
 
-  // Print SPI attributes and decls that are visible only as SPI.
-  bool PrintSPIs = true;
+  PrintInterfaceContentMode InterfaceContentMode;
 
   /// Prints type variables and unresolved types in an expanded notation suitable
   /// for debugging.
@@ -684,7 +689,7 @@ struct PrintOptions {
   static PrintOptions printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
                                               bool preferTypeRepr,
                                               bool printFullConvention,
-                                              bool printSPIs,
+                                              PrintInterfaceContentMode interfaceContentMode,
                                               bool useExportedModuleNames,
                                               bool aliasModuleNames,
                                               llvm::SmallSet<StringRef, 4>

include/swift/Basic/FileTypes.def

@@ -51,6 +51,7 @@ TYPE("swiftmodule",         SwiftModuleFile,           "swiftmodule",     "")
 TYPE("swiftdoc",            SwiftModuleDocFile,        "swiftdoc",        "")
 TYPE("swiftinterface",      SwiftModuleInterfaceFile,  "swiftinterface",  "")
 TYPE("private-swiftinterface", PrivateSwiftModuleInterfaceFile,  "private.swiftinterface",  "")
+TYPE("package-swiftinterface", PackageSwiftModuleInterfaceFile,  "package.swiftinterface",  "")
 TYPE("swiftmodulesummary",  SwiftModuleSummaryFile,    "swiftmodulesummary", "")
 TYPE("swiftsourceinfo",     SwiftSourceInfoFile,       "swiftsourceinfo", "")
 TYPE("assembly",            Assembly,                  "s",               "")

include/swift/Basic/SupplementaryOutputPaths.def

@@ -137,6 +137,14 @@ OUTPUT(ModuleInterfaceOutputPath, TY_SwiftModuleInterfaceFile)
 OUTPUT(PrivateModuleInterfaceOutputPath,
             TY_PrivateSwiftModuleInterfaceFile)
 
+/// The path to which we should emit a package module interface.
+///
+/// The package interface contains package decls, SPIs, and public/inlinable decls.
+///
+/// \sa ModuleInterfaceOutputPath
+OUTPUT(PackageModuleInterfaceOutputPath,
+            TY_PackageSwiftModuleInterfaceFile)
+
 /// The path to which we should emit module summary file.
 OUTPUT(ModuleSummaryOutputPath, TY_SwiftModuleSummaryFile)
 

include/swift/Driver/Action.h

@@ -408,7 +408,8 @@ class VerifyModuleInterfaceJobAction : public JobAction {
     : JobAction(Action::Kind::VerifyModuleInterfaceJob, { ModuleEmitter },
                 file_types::TY_Nothing), inputType(inputType) {
     assert(inputType == file_types::TY_SwiftModuleInterfaceFile ||
-           inputType == file_types::TY_PrivateSwiftModuleInterfaceFile);
+           inputType == file_types::TY_PrivateSwiftModuleInterfaceFile ||
+           inputType == file_types::TY_PackageSwiftModuleInterfaceFile);
   }
 
   file_types::ID getInputType() const { return inputType; }

include/swift/Frontend/Frontend.h

@@ -432,6 +432,7 @@ class CompilerInvocation {
   /// fail an assert if not in that mode.
   std::string getModuleInterfaceOutputPathForWholeModule() const;
   std::string getPrivateModuleInterfaceOutputPathForWholeModule() const;
+  std::string getPackageModuleInterfaceOutputPathForWholeModule() const;
 
   /// APIDescriptorPath only makes sense in whole module compilation mode,
   /// so return the APIDescriptorPath when in that mode and fail an assert

include/swift/Frontend/FrontendInputsAndOutputs.h

@@ -264,6 +264,7 @@ class FrontendInputsAndOutputs {
   bool hasModuleSourceInfoOutputPath() const;
   bool hasModuleInterfaceOutputPath() const;
   bool hasPrivateModuleInterfaceOutputPath() const;
+  bool hasPackageModuleInterfaceOutputPath() const;
   bool hasABIDescriptorOutputPath() const;
   bool hasAPIDescriptorOutputPath() const;
   bool hasConstValuesOutputPath() const;

include/swift/Frontend/ModuleInterfaceSupport.h

@@ -55,8 +55,8 @@ struct ModuleInterfaceOptions {
   /// e.g. -package-name PACKAGE_ID
   std::string IgnorablePrivateFlags;
 
-  /// Print for a private swiftinterface file, SPI decls and attributes.
-  bool PrintPrivateInterfaceContent = false;
+  /// Prints package, SPIs, or public/inlinable decls depending on the mode.
+  PrintInterfaceContentMode InterfaceContentMode = PrintInterfaceContentMode::Public;
 
   /// Print imports with both @_implementationOnly and @_spi, only applies
   /// when PrintSPIs is true.

include/swift/Option/Options.td

@@ -56,8 +56,9 @@ def ModuleInterfaceOption : OptionFlag;
 // The option can be safely ignored by the older compiler.
 def ModuleInterfaceOptionIgnorable : OptionFlag;
 
-// The option should be written into a .private.swiftinterface module interface file,
-// and read/parsed from there when reconstituting a .swiftmodule from it.
+// The option should be written into a .private.swiftinterface or
+// .package.swiftinterface module interface file, and read/parsed from
+// there when reconstituting a .swiftmodule from it.
 // The option can be safely ignored by the older compiler.
 def ModuleInterfaceOptionIgnorablePrivate : OptionFlag;
 
@@ -593,6 +594,12 @@ def emit_private_module_interface_path :
          ArgumentIsPath, SupplementaryOutput, CacheInvariant]>,
   MetaVarName<"<path>">, HelpText<"Output private module interface file to <path>">;
 
+def emit_package_module_interface_path :
+  Separate<["-"], "emit-package-module-interface-path">,
+  Flags<[FrontendOption, NoInteractiveOption, HelpHidden,
+         ArgumentIsPath, SupplementaryOutput, CacheInvariant]>,
+  MetaVarName<"<path>">, HelpText<"Output package module interface file to <path>">;
+
 def verify_emitted_module_interface :
   Flag<["-"], "verify-emitted-module-interface">,
   Flags<[NoInteractiveOption, DoesNotAffectIncrementalBuild]>,

include/swift/Serialization/SerializedModuleLoader.h

@@ -62,11 +62,16 @@ struct SerializedModuleBaseName {
   /// Gets the filename with a particular extension appended to it.
   std::string getName(file_types::ID fileTy) const;
 
-  /// If the interface with \p baseName exists, returns its path (which may be
-  /// the private interface if there is one). Return an empty optional
-  /// otherwise.
+  /// If the interface with \p baseName exists, returns its path (which may be the
+  /// package interface if applicable (in the same package as the main module) or
+  /// private interface if there is one, else public). Return an empty optional otherwise.
   llvm::Optional<std::string>
-  findInterfacePath(llvm::vfs::FileSystem &fs) const;
+  findInterfacePath(llvm::vfs::FileSystem &fs, ASTContext &ctx) const;
+
+  /// Returns the .package.swiftinterface path if its package-name also applies to
+  /// the the importing module. Returns an empty optional otherwise.
+  llvm::Optional<std::string>
+  getPackageInterfacePathIfInSamePackage(llvm::vfs::FileSystem &fs, ASTContext &ctx) const;
 };
 
 /// Common functionality shared between \c ImplicitSerializedModuleLoader,

lib/AST/ASTPrinter.cpp

@@ -117,6 +117,24 @@ static bool isPublicOrUsableFromInline(Type ty) {
   });
 }
 
+static bool isPackage(const ValueDecl *VD) {
+  AccessScope scope =
+      VD->getFormalAccessScope(/*useDC*/nullptr,
+                               /*treatUsableFromInlineAsPublic*/true);
+  return scope.isPackage();
+}
+
+static bool isPackage(Type ty) {
+  // \see isPublicOrUsableFromInline(Type ty)
+  return !ty.findIf([](Type typePart) -> bool {
+    if (auto *aliasTy = dyn_cast<TypeAliasType>(typePart.getPointer()))
+      return !isPackage(aliasTy->getDecl());
+    if (auto *nominal = typePart->getAnyNominal())
+      return !isPackage(nominal);
+    return false;
+  });
+}
+
 static bool isPrespecilizationDeclWithTarget(const ValueDecl *vd) {
   // Add exported prespecialized symbols.
   for (auto *attr : vd->getAttrs().getAttributes<SpecializeAttr>()) {
@@ -156,7 +174,7 @@ static bool shouldTypeCheck(const PrintOptions &options) {
 PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
                                                    bool preferTypeRepr,
                                                    bool printFullConvention,
-                                                   bool printSPIs,
+                                                   PrintInterfaceContentMode interfaceContentMode,
                                                    bool useExportedModuleNames,
                                                    bool aliasModuleNames,
                                                    llvm::SmallSet<StringRef, 4>
@@ -188,7 +206,7 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
     result.PrintFunctionRepresentationAttrs =
       PrintOptions::FunctionRepresentationMode::Full;
   result.AlwaysTryPrintParameterLabels = true;
-  result.PrintSPIs = printSPIs;
+  result.InterfaceContentMode = interfaceContentMode;
   result.DesugarExistentialConstraint = true;
 
   // We should print __consuming, __owned, etc for the module interface file.
@@ -220,7 +238,7 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
         return false;
 
       // Skip SPI decls if `PrintSPIs`.
-      if (!options.PrintSPIs && D->isSPI())
+      if (options.InterfaceContentMode == PrintInterfaceContentMode::Public && D->isSPI())
         return false;
 
       if (auto *VD = dyn_cast<ValueDecl>(D)) {
@@ -234,7 +252,8 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
             if (contributesToParentTypeStorage(ASD))
               return true;
 
-          return false;
+          if (options.InterfaceContentMode != PrintInterfaceContentMode::Package || !isPackage(VD))
+            return false;
         }
 
         // Skip member implementations and @objc overrides in @objcImpl
@@ -268,15 +287,19 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
         }
 
         for (const Requirement &req : ED->getGenericRequirements()) {
-          if (!isPublicOrUsableFromInline(req.getFirstType()))
-            return false;
+          if (!isPublicOrUsableFromInline(req.getFirstType())) {
+            if (options.InterfaceContentMode != PrintInterfaceContentMode::Package || !isPackage(req.getSecondType()))
+              return false;
+          }
 
           switch (req.getKind()) {
           case RequirementKind::Conformance:
           case RequirementKind::Superclass:
           case RequirementKind::SameType:
-            if (!isPublicOrUsableFromInline(req.getSecondType()))
-              return false;
+            if (!isPublicOrUsableFromInline(req.getSecondType())) {
+              if (options.InterfaceContentMode != PrintInterfaceContentMode::Package || !isPackage(req.getSecondType()))
+                return false;
+            }
             break;
           case RequirementKind::SameShape:
           case RequirementKind::Layout:
@@ -1181,8 +1204,8 @@ void PrintAST::printAttributes(const Decl *D) {
       }
     }
 
-    // SPI groups
-    if (Options.PrintSPIs &&
+    // Add SPIs to both private and package interfaces
+    if (Options.InterfaceContentMode != PrintInterfaceContentMode::Public &&
         DeclAttribute::canAttributeAppearOnDeclKind(
           DAK_SPIAccessControl, D->getKind())) {
       interleave(D->getSPIGroups(),
@@ -1270,6 +1293,10 @@ static bool mustPrintPropertyName(VarDecl *decl, const PrintOptions &opts) {
   //        if we serialized references to them using field indices.
   if (contributesToParentTypeStorage(decl)) return true;
 
+  // Print a package decl if in print package mode (for .package.swiftinterface),
+  if (opts.InterfaceContentMode == PrintInterfaceContentMode::Package && isPackage(decl))
+    return true;
+
   // If it's public or @usableFromInline, we must print the name because it's a
   // visible entry-point.
   if (isPublicOrUsableFromInline(decl)) return true;
@@ -5979,8 +6006,8 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     ModuleDecl::ImportFilter Filter = ModuleDecl::ImportFilterKind::Exported;
     Filter |= ModuleDecl::ImportFilterKind::Default;
 
-    // For private swiftinterfaces, also look through @_spiOnly imports.
-    if (Options.PrintSPIs)
+    // For private or package swiftinterfaces, also look through @_spiOnly imports.
+    if (Options.InterfaceContentMode != PrintInterfaceContentMode::Public)
       Filter |= ModuleDecl::ImportFilterKind::SPIOnly;
 
     SmallVector<ImportedModule, 4> Imports;