Merge pull request #60659 from xymus/print-missing-imports

[ModuleInterface] Print missing imports in swiftinterface

Author: xymus

include/swift/AST/DiagnosticsSema.def

@@ -5855,6 +5855,10 @@ ERROR(inlinable_typealias_desugars_to_type_from_hidden_module,
       "%4 was not imported by this file}5",
       (DeclName, StringRef, StringRef, unsigned, Identifier, unsigned))
 
+NOTE(missing_import_inserted,
+     none, "The missing import of module %0 will be added implicitly",
+     (Identifier))
+
 ERROR(availability_macro_in_inlinable, none,
       "availability macro cannot be used in " FRAGILE_FUNC_KIND "0",
       (unsigned))

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

@@ -712,6 +712,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,21 @@ RestrictedImportKind SourceFile::getRestrictedImportKind(const ModuleDecl *modul
   if (imports.isImportedBy(module, getParentModule()))
     return RestrictedImportKind::None;
 
+  if (importKind == RestrictedImportKind::Implicit &&
+      (module->getLibraryLevel() == LibraryLevel::API ||
+       getParentModule()->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);
 

lib/Sema/ResilienceDiagnostics.cpp

@@ -144,6 +144,11 @@ static bool diagnoseTypeAliasDeclRefExportability(SourceLoc loc,
   }
   D->diagnose(diag::kind_declared_here, DescriptiveDeclKind::Type);
 
+  if (originKind == DisallowedOriginKind::ImplicitlyImported &&
+      !ctx.LangOpts.isSwiftVersionAtLeast(6))
+    ctx.Diags.diagnose(loc, diag::missing_import_inserted,
+                       definingModule->getName());
+
   return true;
 }
 
@@ -190,7 +195,13 @@ static bool diagnoseValueDeclRefExportability(SourceLoc loc, const ValueDecl *D,
                        D->getDescriptiveKind(), D->getName(),
                        fragileKind.getSelector(), definingModule->getName(),
                        static_cast<unsigned>(originKind));
+
+    if (originKind == DisallowedOriginKind::ImplicitlyImported &&
+        downgradeToWarning == DowngradeToWarning::Yes)
+      ctx.Diags.diagnose(loc, diag::missing_import_inserted,
+                         definingModule->getName());
   }
+
   return true;
 }
 
@@ -245,5 +256,10 @@ TypeChecker::diagnoseConformanceExportability(SourceLoc loc,
                                 !ctx.LangOpts.EnableConformanceAvailabilityErrors) ||
                                originKind == DisallowedOriginKind::ImplicitlyImported,
                                6);
+
+    if (originKind == DisallowedOriginKind::ImplicitlyImported &&
+        !ctx.LangOpts.isSwiftVersionAtLeast(6))
+      ctx.Diags.diagnose(loc, diag::missing_import_inserted,
+                         M->getName());
   return true;
 }