Merge pull request #62251 from nkcsgexi/allowable-serialization

serialization: encode allowable client names in binary module format

Author: nkcsgexi

include/swift/AST/DiagnosticsSema.def

@@ -984,6 +984,10 @@ WARNING(module_not_compiled_with_library_evolution,none,
         "using it means binary compatibility for %1 can't be guaranteed",
         (Identifier, Identifier))
 
+ERROR(module_allowable_client_violation,none,
+      "module %0 doesn't allow importation from module %1",
+      (Identifier, Identifier))
+
 REMARK(cross_import_added,none,
        "import of %0 and %1 triggered a cross-import of %2",
        (Identifier, Identifier, Identifier))

include/swift/AST/Module.h

@@ -418,7 +418,19 @@ class ModuleDecl
     return UserModuleVersion;
   }
 
+  void addAllowableClientName(Identifier name) {
+    allowableClientNames.push_back(name);
+  }
+  ArrayRef<Identifier> getAllowableClientNames() const {
+    return allowableClientNames;
+  }
+  bool allowImportedBy(ModuleDecl *importer) const;
 private:
+
+  /// An array of module names that are allowed to import this one.
+  /// Any module can import this one if empty.
+  std::vector<Identifier> allowableClientNames;
+
   /// A cache of this module's underlying module and required bystander if it's
   /// an underscored cross-import overlay.
   Optional<std::pair<ModuleDecl *, Identifier>> declaringModuleAndBystander;

include/swift/Frontend/FrontendOptions.h

@@ -97,6 +97,9 @@ class FrontendOptions {
   /// User-defined module version number.
   llvm::VersionTuple UserModuleVersion;
 
+  /// A set of modules allowed to import this module.
+  std::set<std::string> AllowableClients;
+
   /// Emit index data for imported serialized swift system modules.
   bool IndexSystemModules = false;
 

include/swift/Serialization/SerializationOptions.h

@@ -35,6 +35,7 @@ namespace swift {
     std::string ABIDescriptorPath;
     bool emptyABIDescriptor = false;
     llvm::VersionTuple UserModuleVersion;
+    std::set<std::string> AllowableClients;
     std::string SDKName;
 
     StringRef GroupInfoPath;

include/swift/Serialization/Validation.h

@@ -93,6 +93,7 @@ struct ValidationInfo {
   StringRef sdkName = {};
   size_t bytes = 0;
   Status status = Status::Malformed;
+  std::vector<StringRef> allowableClients;
 };
 
 /// A collection of options that can be used to set up a new AST context

lib/AST/Module.cpp

@@ -1923,6 +1923,18 @@ Identifier ModuleDecl::getRealName() const {
   return getASTContext().getRealModuleName(getName());
 }
 
+bool ModuleDecl::allowImportedBy(ModuleDecl *importer) const {
+  if (allowableClientNames.empty())
+    return true;
+  for (auto id: allowableClientNames) {
+    if (importer->getRealName() == id)
+      return true;
+    if (importer->getABIName() == id)
+      return true;
+  }
+  return false;
+}
+
 Identifier ModuleDecl::getABIName() const {
   if (!ModuleABIName.empty())
     return ModuleABIName;

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -120,6 +120,10 @@ bool ArgsToFrontendOptionsConverter::convert(
     }
   }
 
+  for (auto A : Args.getAllArgValues(options::OPT_allowable_client)) {
+    Opts.AllowableClients.insert(StringRef(A).str());
+  }
+
   Opts.DisableImplicitModules |= Args.hasArg(OPT_disable_implicit_swift_modules);
 
   Opts.ImportPrescan |= Args.hasArg(OPT_import_prescan);

lib/Frontend/Frontend.cpp

@@ -154,6 +154,7 @@ SerializationOptions CompilerInvocation::computeSerializationOptions(
     serializationOpts.ImportedHeader = opts.ImplicitObjCHeaderPath;
   serializationOpts.ModuleLinkName = opts.ModuleLinkName;
   serializationOpts.UserModuleVersion = opts.UserModuleVersion;
+  serializationOpts.AllowableClients = opts.AllowableClients;
 
   serializationOpts.PublicDependentLibraries =
       getIRGenOptions().PublicLinkLibraries;

lib/Frontend/ModuleInterfaceBuilder.cpp

@@ -266,6 +266,7 @@ std::error_code ExplicitModuleInterfaceBuilder::buildSwiftModuleFromInterface(
   SerializationOpts.AutolinkForceLoad =
       !Invocation.getIRGenOptions().ForceLoadSymbolName.empty();
   SerializationOpts.UserModuleVersion = FEOpts.UserModuleVersion;
+  SerializationOpts.AllowableClients = FEOpts.AllowableClients;
 
   // Record any non-SDK module interface files for the debug info.
   StringRef SDKPath = Instance.getASTContext().SearchPathOpts.getSDKPath();

lib/Sema/ImportResolution.cpp

@@ -137,6 +137,7 @@ struct UnboundImport {
   void validateTestable(ModuleDecl *topLevelModule);
   void validateResilience(NullablePtr<ModuleDecl> topLevelModule,
                           SourceFile &SF);
+  void validateAllowableClient(ModuleDecl *topLevelModule, SourceFile &SF);
 
   /// Diagnoses an inability to import \p modulePath in this situation and, if
   /// \p attrs is provided and has an \p attrKind, invalidates the attribute and
@@ -621,6 +622,7 @@ void UnboundImport::validateOptions(NullablePtr<ModuleDecl> topLevelModule,
     // changing behavior, but it smells funny.
     validateTestable(top);
     validatePrivate(top);
+    validateAllowableClient(top, SF);
   }
 
   validateResilience(topLevelModule, SF);
@@ -712,6 +714,19 @@ void UnboundImport::validateTestable(ModuleDecl *topLevelModule) {
   diagnoseInvalidAttr(DAK_Testable, ctx.Diags, diag::module_not_testable);
 }
 
+void UnboundImport::validateAllowableClient(ModuleDecl *importee,
+                                            SourceFile &SF) {
+  assert(importee);
+  auto *importer = SF.getParentModule();
+  if (!importee->allowImportedBy(importer)) {
+    ASTContext &ctx = SF.getASTContext();
+    ctx.Diags.diagnose(import.module.getModulePath().front().Loc,
+                       diag::module_allowable_client_violation,
+                       importee->getName(),
+                       importer->getName());
+  }
+}
+
 void UnboundImport::validateResilience(NullablePtr<ModuleDecl> topLevelModule,
                                        SourceFile &SF) {
   if (import.options.contains(ImportFlags::ImplementationOnly))