[ModuleInterface] Print missing imports in swiftinterface

Hack to fix swiftinterfaces in case of missing imports. We can get rid
of this logic when we don't leak the use of non-locally imported things
in API.

Author: xymus

include/swift/AST/FileUnit.h

@@ -271,6 +271,10 @@ class FileUnit : public DeclContext, public ASTAllocated<FileUnit> {
   getImportedModules(SmallVectorImpl<ImportedModule> &imports,
                      ModuleDecl::ImportFilter filter) const {}
 
+  /// Lists modules that are not imported from this file and used in API.
+  virtual void
+  getMissingImportedModules(SmallVectorImpl<ImportedModule> &imports) const {}
+
   /// \see ModuleDecl::getImportedModulesForLookup
   virtual void getImportedModulesForLookup(
       SmallVectorImpl<ImportedModule> &imports) const {

include/swift/AST/Module.h

@@ -713,6 +713,10 @@ class ModuleDecl
   void getImportedModules(SmallVectorImpl<ImportedModule> &imports,
                           ImportFilter filter = ImportFilterKind::Exported) const;
 
+  /// Lists modules that are not imported from a file and used in API.
+  void
+  getMissingImportedModules(SmallVectorImpl<ImportedModule> &imports) const;
+
   /// Looks up which modules are imported by this module, ignoring any that
   /// won't contain top-level decls.
   ///

include/swift/AST/SourceFile.h

@@ -399,6 +399,15 @@ class SourceFile final : public FileUnit {
 
   SWIFT_DEBUG_DUMPER(dumpSeparatelyImportedOverlays());
 
+  llvm::SmallDenseSet<ImportedModule> MissingImportedModules;
+
+  void addMissingImportedModule(ImportedModule module) const {
+     const_cast<SourceFile *>(this)->MissingImportedModules.insert(module);
+  }
+
+  void getMissingImportedModules(
+         SmallVectorImpl<ImportedModule> &imports) const override;
+
   void cacheVisibleDecls(SmallVectorImpl<ValueDecl *> &&globals) const;
   const SmallVectorImpl<ValueDecl *> &getCachedVisibleDecls() const;
 

include/swift/Frontend/ModuleInterfaceSupport.h

@@ -53,6 +53,9 @@ struct ModuleInterfaceOptions {
   /// when PrintSPIs is true.
   bool ExperimentalSPIImports = false;
 
+  /// Print imports that are missing from the source and used in API.
+  bool PrintMissingImports = true;
+
   /// Intentionally print invalid syntax into the file.
   bool DebugPrintInvalidSyntax = false;
 

include/swift/Option/FrontendOptions.td

@@ -900,6 +900,11 @@ def experimental_spi_imports :
   Flag<["-"], "experimental-spi-imports">,
   HelpText<"Enable experimental support for SPI imports">;
 
+def disable_print_missing_imports_in_module_interface :
+  Flag<["-"], "disable-print-missing-imports-in-module-interface">,
+  HelpText<"Disable adding to the module interface imports used from API and "
+           "missing from the sources">;
+
 // [FIXME: Clang-type-plumbing] Make this a SIL-only option once we start
 // unconditionally emitting non-canonical Clang types in swiftinterfaces.
 def experimental_print_full_convention :

lib/AST/Module.cpp

@@ -1570,6 +1570,11 @@ void ModuleDecl::getImportedModules(SmallVectorImpl<ImportedModule> &modules,
   FORWARD(getImportedModules, (modules, filter));
 }
 
+void ModuleDecl::getMissingImportedModules(
+    SmallVectorImpl<ImportedModule> &imports) const {
+  FORWARD(getMissingImportedModules, (imports));
+}
+
 void
 SourceFile::getImportedModules(SmallVectorImpl<ImportedModule> &modules,
                                ModuleDecl::ImportFilter filter) const {
@@ -1604,6 +1609,12 @@ SourceFile::getImportedModules(SmallVectorImpl<ImportedModule> &modules,
   }
 }
 
+void SourceFile::getMissingImportedModules(
+    SmallVectorImpl<ImportedModule> &modules) const {
+  for (auto module : MissingImportedModules)
+    modules.push_back(module);
+}
+
 void SourceFile::dumpSeparatelyImportedOverlays() const {
   for (auto &pair : separatelyImportedOverlays) {
     auto &underlying = std::get<0>(pair);
@@ -2535,6 +2546,20 @@ RestrictedImportKind SourceFile::getRestrictedImportKind(const ModuleDecl *modul
   if (imports.isImportedBy(module, getParentModule()))
     return RestrictedImportKind::None;
 
+  if (importKind == RestrictedImportKind::Implicit &&
+      module->getLibraryLevel() == LibraryLevel::API) {
+    // Hack to fix swiftinterfaces in case of missing imports.
+    // We can get rid of this logic when we don't leak the use of non-locally
+    // imported things in API.
+    ImportPath::Element pathElement = {module->getName(), SourceLoc()};
+    auto pathArray = getASTContext().AllocateCopy(
+                       llvm::makeArrayRef(pathElement));
+    auto missingImport = ImportedModule(
+                           ImportPath::Access(pathArray),
+                           const_cast<ModuleDecl *>(module));
+    addMissingImportedModule(missingImport);
+  }
+
   return importKind;
 }
 

lib/Frontend/CompilerInvocation.cpp

@@ -373,6 +373,8 @@ static void ParseModuleInterfaceArgs(ModuleInterfaceOptions &Opts,
     Args.hasArg(OPT_experimental_spi_imports);
   Opts.DebugPrintInvalidSyntax |=
     Args.hasArg(OPT_debug_emit_invalid_swiftinterface_syntax);
+  Opts.PrintMissingImports =
+    !Args.hasArg(OPT_disable_print_missing_imports_in_module_interface);
 
   if (const Arg *A = Args.getLastArg(OPT_library_level)) {
     StringRef contents = A->getValue();

lib/Frontend/ModuleInterfaceSupport.cpp

@@ -219,6 +219,10 @@ static void printImports(raw_ostream &out,
 
   SmallVector<ImportedModule, 8> allImports;
   M->getImportedModules(allImports, allImportFilter);
+
+  if (Opts.PrintMissingImports)
+    M->getMissingImportedModules(allImports);
+
   ImportedModule::removeDuplicates(allImports);
   diagnoseScopedImports(M->getASTContext().Diags, allImports);
 

test/Sema/implicit-import-in-inlinable-code.swift

@@ -16,6 +16,14 @@
 /// In Swift 6, it's an error.
 // RUN: %target-swift-frontend -emit-module %t/clientFileA-Swift6.swift %t/clientFileB.swift -module-name client -o %t/client.swiftmodule -I %t -verify -swift-version 6
 
+/// The swiftinterface is broken by the missing import without the workaround.
+// RUN: %target-swift-emit-module-interface(%t/ClientBroken.swiftinterface)  %t/clientFileA-Swift5.swift %t/clientFileB.swift -I %t -disable-print-missing-imports-in-module-interface
+// RUN: not %target-swift-typecheck-module-from-interface(%t/ClientBroken.swiftinterface) -I %t
+
+/// The swiftinterface parses fine with the workaround adding the missing imports.
+// RUN: %target-swift-emit-module-interface(%t/ClientFixed.swiftinterface)  %t/clientFileA-Swift5.swift %t/clientFileB.swift -I %t
+// RUN: %target-swift-typecheck-module-from-interface(%t/ClientFixed.swiftinterface) -I %t
+
 // REQUIRES: asserts
 
 // BEGIN empty.swift

test/Sema/implicit-import-typealias.swift

@@ -11,6 +11,19 @@
 // RUN: %target-swift-frontend -typecheck -verify %t/UsesAliasesImplementationOnlyImport.swift -I %t
 // RUN: %target-swift-frontend -typecheck -verify %t/UsesAliasesWithImport.swift  -I %t
 
+/// The swiftinterface is broken by the missing import without the workaround.
+// RUN: %target-swift-emit-module-interface(%t/UsesAliasesNoImport.swiftinterface) %t/UsesAliasesNoImport.swift -I %t \
+// RUN:   -disable-print-missing-imports-in-module-interface
+// RUN: not %target-swift-typecheck-module-from-interface(%t/UsesAliasesNoImport.swiftinterface) -I %t
+
+/// The swiftinterface parses fine with the workaround adding the missing imports.
+// RUN: %target-swift-emit-module-interface(%t/UsesAliasesNoImportFixed.swiftinterface) %t/UsesAliasesNoImport.swift -I %t
+// RUN: %target-swift-typecheck-module-from-interface(%t/UsesAliasesNoImportFixed.swiftinterface) -I %t
+
+/// The module with an implementation-only import is not affected by the workaround and remains broken.
+// RUN: %target-swift-emit-module-interface(%t/UsesAliasesImplementationOnlyImport.swiftinterface) %t/UsesAliasesImplementationOnlyImport.swift -I %t \
+// RUN:   -disable-print-missing-imports-in-module-interface
+// RUN: not %target-swift-typecheck-module-from-interface(%t/UsesAliasesImplementationOnlyImport.swiftinterface) -I %t
 
 //--- Original.swift