Add support for textual imports to -emit-objc-header

Nuri Amari · Nuri Amari · commit 5fbec4c9f43b · 2022-09-27T15:48:24.000-07:00
Currently headers produced with `-emit-objc-header` /
`-emit-objc-header-path` produce headers that include modular imports.
If the consumer wishes to operate without modules enabled, these headers
cannot be used. This patch introduces a new flag
(`-emit-objc-header-textually`) that when enabled
attempts to argument each modular import included in such a header with
a set of equivalent textual imports.
diff --git a/include/swift/Frontend/FrontendOptions.h b/include/swift/Frontend/FrontendOptions.h
@@ -466,6 +466,10 @@ class FrontendOptions {
   /// crashes the compiler.
   bool emptyABIDescriptor = false;
 
+  /// Augment modular imports in any emitted ObjC headers with equivalent
+  /// textual imports
+  bool EmitObjCHeaderWithTextualImports = false;
+
 private:
   static bool canActionEmitDependencies(ActionType);
   static bool canActionEmitReferenceDependencies(ActionType);
diff --git a/include/swift/Option/Options.td b/include/swift/Option/Options.td
@@ -552,6 +552,9 @@ def emit_objc_header_path : Separate<["-"], "emit-objc-header-path">,
   Flags<[FrontendOption, NoInteractiveOption, ArgumentIsPath,
          SupplementaryOutput]>,
   MetaVarName<"<path>">, HelpText<"Emit an Objective-C header file to <path>">;
+def emit_objc_header_textually : Flag<["-"], "emit-objc-header-textually">,
+  Flags<[FrontendOption, NoInteractiveOption, SupplementaryOutput]>,
+  HelpText<"Augment emitted Objective-C header with textual imports for every included modular import">;
 
 def emit_clang_header_path : Separate<["-"], "emit-clang-header-path">,
   Flags<[FrontendOption, NoDriverOption, NoInteractiveOption, ArgumentIsPath,
diff --git a/include/swift/PrintAsClang/PrintAsClang.h b/include/swift/PrintAsClang/PrintAsClang.h
@@ -17,10 +17,15 @@
 #include "swift/AST/AttrKind.h"
 #include "swift/AST/Identifier.h"
 
+namespace clang {
+class HeaderSearch;
+}
+
 namespace swift {
 class IRGenOptions;
 class ModuleDecl;
 class ValueDecl;
+class FrontendOptions;
 
 /// Print the exposed declarations in a module into a Clang header.
 ///
@@ -35,7 +40,9 @@ class ValueDecl;
 bool printAsClangHeader(raw_ostream &out, ModuleDecl *M,
                         StringRef bridgingHeader,
                         bool ExposePublicDeclsInClangHeader,
-                        const IRGenOptions &irGenOpts);
+                        const IRGenOptions &irGenOpts,
+                        const FrontendOptions &frontendOpts,
+                        clang::HeaderSearch &headerSearchInfo);
 }
 
 #endif
diff --git a/lib/Frontend/ArgsToFrontendOptionsConverter.cpp b/lib/Frontend/ArgsToFrontendOptionsConverter.cpp
@@ -85,6 +85,9 @@ bool ArgsToFrontendOptionsConverter::convert(
   Opts.FrontendParseableOutput |= Args.hasArg(OPT_frontend_parseable_output);
   Opts.ExplicitInterfaceBuild |= Args.hasArg(OPT_explicit_interface_module_build);
 
+  Opts.EmitObjCHeaderWithTextualImports |=
+      Args.hasArg(OPT_emit_objc_header_textually);
+
   // FIXME: Remove this flag
   Opts.EnableLibraryEvolution |= Args.hasArg(OPT_enable_resilience);
 
diff --git a/lib/FrontendTool/FrontendTool.cpp b/lib/FrontendTool/FrontendTool.cpp
@@ -72,6 +72,8 @@
 #include "swift/Syntax/SyntaxNodes.h"
 #include "swift/TBDGen/TBDGen.h"
 
+#include "clang/Lex/Preprocessor.h"
+
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/IR/LLVMContext.h"
@@ -179,16 +181,18 @@ static bool writeSIL(SILModule &SM, const PrimarySpecificPaths &PSPs,
 /// \returns true if there were any errors
 ///
 /// \see swift::printAsClangHeader
-static bool printAsClangHeaderIfNeeded(StringRef outputPath, ModuleDecl *M,
-                                       StringRef bridgingHeader,
-                                       bool ExposePublicDeclsInClangHeader,
-                                       const IRGenOptions &irGenOpts) {
+static bool printAsClangHeaderIfNeeded(
+    StringRef outputPath, ModuleDecl *M, StringRef bridgingHeader,
+    bool ExposePublicDeclsInClangHeader, const IRGenOptions &irGenOpts,
+    const FrontendOptions &frontendOpts,
+    clang::HeaderSearch &clangHeaderSearchInfo) {
   if (outputPath.empty())
     return false;
   return withOutputFile(
       M->getDiags(), outputPath, [&](raw_ostream &out) -> bool {
         return printAsClangHeader(out, M, bridgingHeader,
-                                  ExposePublicDeclsInClangHeader, irGenOpts);
+                                  ExposePublicDeclsInClangHeader, irGenOpts,
+                                  frontendOpts, clangHeaderSearchInfo);
       });
 }
 
@@ -937,7 +941,10 @@ static bool emitAnyWholeModulePostTypeCheckSupplementaryOutputs(
     hadAnyError |= printAsClangHeaderIfNeeded(
         Invocation.getClangHeaderOutputPathForAtMostOnePrimary(),
         Instance.getMainModule(), BridgingHeaderPathForPrint,
-        opts.ExposePublicDeclsInClangHeader, Invocation.getIRGenOptions());
+        opts.ExposePublicDeclsInClangHeader, Invocation.getIRGenOptions(), opts,
+        Context.getClangModuleLoader()
+            ->getClangPreprocessor()
+            .getHeaderSearchInfo());
   }
 
   // Only want the header if there's been any errors, ie. there's not much
diff --git a/lib/PrintAsClang/PrintAsClang.cpp b/lib/PrintAsClang/PrintAsClang.cpp
@@ -20,9 +20,13 @@
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/Basic/Version.h"
 #include "swift/ClangImporter/ClangImporter.h"
+#include "swift/Frontend/FrontendOptions.h"
 
+#include "clang/Basic/FileManager.h"
 #include "clang/Basic/Module.h"
+#include "clang/Lex/HeaderSearch.h"
 
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace swift;
@@ -393,9 +397,140 @@ static int compareImportModulesByName(const ImportModuleTy *left,
   return 1;
 }
 
+static llvm::SmallString<128> makePathAbsolute(const llvm::StringRef path,
+                                               const llvm::StringRef cwd) {
+  if (llvm::sys::path::is_absolute(path))
+    return llvm::SmallString<128>(path);
+
+  llvm::SmallString<128> result = cwd;
+  llvm::sys::path::append(result,
+                          llvm::sys::path::remove_leading_dotslash(path));
+  return result;
+}
+
+// Collect the set of header includes needed to import the given Clang module
+// into an ObjectiveC program. Modeled after collectModuleHeaderIncludes in the
+// Clang frontend (FrontendAction.cpp)
+// Augment requiredTextualIncludes with the set of headers required.
+static void collectClangModuleHeaderIncludes(
+    const clang::Module *clangModule, clang::FileManager &fileManager,
+    llvm::SmallSet<llvm::SmallString<128>, 10> &requiredTextualIncludes,
+    llvm::SmallSet<const clang::Module *, 10> &visitedModules,
+    const llvm::SmallSet<llvm::SmallString<128>, 10> &includeDirs,
+    const llvm::StringRef cwd) {
+
+  if (!visitedModules.insert(clangModule).second)
+    return;
+
+  auto addHeader = [&](llvm::StringRef headerPath,
+                       llvm::StringRef pathRelativeToRootModuleDir) {
+    if (!clangModule->Directory)
+      return;
+
+    llvm::SmallString<128> textualInclude = makePathAbsolute(headerPath, cwd);
+    llvm::SmallString<128> containingSearchDirPath;
+
+    // Check if the module map lies either in an include dir or in a direct
+    // subdirectory of an include dir
+    llvm::SmallString<128> moduleMapDir =
+        makePathAbsolute(clangModule->Directory->getName(), cwd);
+    llvm::SmallString<128> moduleMapDirParent =
+        llvm::sys::path::parent_path(moduleMapDir);
+
+    for (auto &dir : {moduleMapDir, moduleMapDirParent}) {
+      if (includeDirs.contains(dir)) {
+        containingSearchDirPath = dir;
+        break;
+      }
+    }
+
+    if (!containingSearchDirPath.empty()) {
+      llvm::SmallString<128> prefixToRemove =
+          llvm::formatv("{0}/", containingSearchDirPath);
+      llvm::sys::path::replace_path_prefix(textualInclude, prefixToRemove, "");
+    } else {
+      // If we cannot find find the module map on the search path,
+      // fallback to including the header using the provided path relative
+      // to the module map
+      textualInclude = pathRelativeToRootModuleDir;
+    }
+
+    if (clangModule->getTopLevelModule()->IsFramework) {
+      llvm::SmallString<32> frameworkName =
+          clangModule->getTopLevelModuleName();
+      llvm::SmallString<64> oldFrameworkPrefix =
+          llvm::formatv("{0}.framework/Headers", frameworkName);
+      llvm::sys::path::replace_path_prefix(textualInclude, oldFrameworkPrefix,
+                                           frameworkName);
+    }
+
+    requiredTextualIncludes.insert(textualInclude);
+  };
+
+  if (clang::Module::Header umbrellaHeader = clangModule->getUmbrellaHeader()) {
+    addHeader(umbrellaHeader.Entry->getName(),
+              umbrellaHeader.PathRelativeToRootModuleDirectory);
+  } else if (clang::Module::DirectoryName umbrellaDir =
+                 clangModule->getUmbrellaDir()) {
+    SmallString<128> nativeUmbrellaDirPath;
+    std::error_code errorCode;
+    llvm::sys::path::native(umbrellaDir.Entry->getName(),
+                            nativeUmbrellaDirPath);
+    llvm::vfs::FileSystem &fileSystem = fileManager.getVirtualFileSystem();
+    for (llvm::vfs::recursive_directory_iterator
+             dir(fileSystem, nativeUmbrellaDirPath, errorCode),
+         end;
+         dir != end && !errorCode; dir.increment(errorCode)) {
+
+      if (llvm::StringSwitch<bool>(llvm::sys::path::extension(dir->path()))
+              .Cases(".h", ".H", ".hh", ".hpp", true)
+              .Default(false)) {
+
+        // Compute path to the header relative to the root of the module
+        // (location of the module map) First compute the relative path from
+        // umbrella directory to header file
+        SmallVector<StringRef> pathComponents;
+        auto pathIt = llvm::sys::path::rbegin(dir->path());
+
+        for (int i = 0; i != dir.level() + 1; ++i, ++pathIt)
+          pathComponents.push_back(*pathIt);
+        // Then append this to the path from module root to umbrella dir
+        SmallString<128> relativeHeaderPath;
+        if (umbrellaDir.PathRelativeToRootModuleDirectory != ".")
+          relativeHeaderPath += umbrellaDir.PathRelativeToRootModuleDirectory;
+
+        for (auto it = pathComponents.rbegin(), end = pathComponents.rend();
+             it != end; ++it) {
+          llvm::sys::path::append(relativeHeaderPath, *it);
+        }
+
+        addHeader(dir->path(), relativeHeaderPath);
+      }
+    }
+  } else {
+    for (clang::Module::HeaderKind headerKind :
+         {clang::Module::HK_Normal, clang::Module::HK_Textual}) {
+      for (const clang::Module::Header &header :
+           clangModule->Headers[headerKind]) {
+        addHeader(header.Entry->getName(),
+                  header.PathRelativeToRootModuleDirectory);
+      }
+    }
+    llvm::SmallVector<clang::Module *> exportedModules;
+    clangModule->getExportedModules(exportedModules);
+    for (auto exportedModule : exportedModules) {
+      collectClangModuleHeaderIncludes(exportedModule, fileManager,
+                                       requiredTextualIncludes, visitedModules,
+                                       includeDirs, cwd);
+    }
+  }
+}
+
 static void writeImports(raw_ostream &out,
                          llvm::SmallPtrSetImpl<ImportModuleTy> &imports,
                          ModuleDecl &M, StringRef bridgingHeader,
+                         const FrontendOptions &frontendOpts,
+                         clang::HeaderSearch &clangHeaderSearchInfo,
                          bool useCxxImport = false) {
   // Note: we can't use has_feature(modules) as it's always enabled in C++20
   // mode.
@@ -420,6 +555,45 @@ static void writeImports(raw_ostream &out,
     return import == importer->getImportedHeaderModule();
   };
 
+  clang::FileSystemOptions fileSystemOptions;
+  clang::FileManager fileManager{fileSystemOptions};
+
+  llvm::SmallSet<llvm::SmallString<128>, 10> requiredTextualIncludes;
+  llvm::SmallSet<const clang::Module *, 10> visitedModules;
+  llvm::SmallSet<llvm::SmallString<128>, 10> includeDirs;
+
+  llvm::vfs::FileSystem &fileSystem = fileManager.getVirtualFileSystem();
+  llvm::ErrorOr<std::string> cwd = fileSystem.getCurrentWorkingDirectory();
+
+  if (frontendOpts.EmitObjCHeaderWithTextualImports) {
+    assert(cwd && "Access to current working directory required");
+
+    for (auto searchDir = clangHeaderSearchInfo.search_dir_begin();
+         searchDir != clangHeaderSearchInfo.search_dir_end(); ++searchDir) {
+      includeDirs.insert(makePathAbsolute(searchDir->getName(), cwd.get()));
+    }
+
+    const clang::Module *foundationModule = clangHeaderSearchInfo.lookupModule(
+        "Foundation", clang::SourceLocation(), false, false);
+    const clang::Module *darwinModule = clangHeaderSearchInfo.lookupModule(
+        "Darwin", clang::SourceLocation(), false, false);
+
+    std::function<void(const clang::Module *)>
+        collectTransitiveSubmoduleClosure;
+    collectTransitiveSubmoduleClosure = [&](const clang::Module *module) {
+      if (!module)
+        return;
+
+      visitedModules.insert(module);
+      for (auto submodule : module->submodules()) {
+        collectTransitiveSubmoduleClosure(submodule);
+      }
+    };
+
+    collectTransitiveSubmoduleClosure(foundationModule);
+    collectTransitiveSubmoduleClosure(darwinModule);
+  }
+
   // Track printed names to handle overlay modules.
   llvm::SmallPtrSet<Identifier, 8> seenImports;
   bool includeUnderlying = false;
@@ -432,18 +606,46 @@ static void writeImports(raw_ostream &out,
         includeUnderlying = true;
         continue;
       }
-      if (seenImports.insert(Name).second)
+      if (seenImports.insert(Name).second) {
         out << importDirective << ' ' << Name.str() << ";\n";
+        if (frontendOpts.EmitObjCHeaderWithTextualImports) {
+          if (const clang::Module *underlyingClangModule =
+                  swiftModule->findUnderlyingClangModule()) {
+            collectClangModuleHeaderIncludes(
+                underlyingClangModule, fileManager, requiredTextualIncludes,
+                visitedModules, includeDirs, cwd.get());
+          } else if ((underlyingClangModule =
+                          clangHeaderSearchInfo.lookupModule(
+                              Name.str(), clang::SourceLocation(), true,
+                              true))) {
+            collectClangModuleHeaderIncludes(
+                underlyingClangModule, fileManager, requiredTextualIncludes,
+                visitedModules, includeDirs, cwd.get());
+          }
+        }
+      }
     } else {
       const auto *clangModule = import.get<const clang::Module *>();
       assert(clangModule->isSubModule() &&
              "top-level modules should use a normal swift::ModuleDecl");
       out << importDirective << ' ';
       ModuleDecl::ReverseFullNameIterator(clangModule).printForward(out);
       out << ";\n";
+
+      if (frontendOpts.EmitObjCHeaderWithTextualImports) {
+        collectClangModuleHeaderIncludes(
+            clangModule, fileManager, requiredTextualIncludes, visitedModules,
+            includeDirs, cwd.get());
+      }
     }
   }
 
+  if (frontendOpts.EmitObjCHeaderWithTextualImports) {
+    out << "#else\n";
+    for (auto header : requiredTextualIncludes) {
+      out << "#import <" << header << ">\n";
+    }
+  }
   out << "#endif\n\n";
 
   if (includeUnderlying) {
@@ -507,7 +709,9 @@ static std::string getModuleContentsCxxString(
 bool swift::printAsClangHeader(raw_ostream &os, ModuleDecl *M,
                                StringRef bridgingHeader,
                                bool ExposePublicDeclsInClangHeader,
-                               const IRGenOptions &irGenOpts) {
+                               const IRGenOptions &irGenOpts,
+                               const FrontendOptions &frontendOpts,
+                               clang::HeaderSearch &clangHeaderSearchInfo) {
   llvm::PrettyStackTraceString trace("While generating Clang header");
 
   SwiftToClangInteropContext interopContext(*M, irGenOpts);
@@ -517,8 +721,10 @@ bool swift::printAsClangHeader(raw_ostream &os, ModuleDecl *M,
   llvm::raw_string_ostream objcModuleContents{objcModuleContentsBuf};
   printModuleContentsAsObjC(objcModuleContents, imports, *M, interopContext);
   writePrologue(os, M->getASTContext(), computeMacroGuard(M));
-  emitObjCConditional(os,
-                      [&] { writeImports(os, imports, *M, bridgingHeader); });
+  emitObjCConditional(os, [&] {
+    writeImports(os, imports, *M, bridgingHeader, frontendOpts,
+                 clangHeaderSearchInfo);
+  });
   writePostImportPrologue(os, *M);
   emitObjCConditional(os, [&] { os << objcModuleContents.str(); });
   emitCxxConditional(os, [&] {
@@ -530,7 +736,8 @@ bool swift::printAsClangHeader(raw_ostream &os, ModuleDecl *M,
           *M, imports, interopContext,
           /*requiresExposedAttribute=*/!ExposePublicDeclsInClangHeader);
       // FIXME: In ObjC++ mode, we do not need to reimport duplicate modules.
-      writeImports(os, imports, *M, bridgingHeader, /*useCxxImport=*/true);
+      writeImports(os, imports, *M, bridgingHeader, frontendOpts,
+                   clangHeaderSearchInfo, /*useCxxImport=*/true);
       os << contents;
     }
   });
diff --git a/test/PrintAsObjC/emit-objc-header-textually-mock-sdk.swift b/test/PrintAsObjC/emit-objc-header-textually-mock-sdk.swift
diff --git a/test/PrintAsObjC/emit-objc-header-textually.swift b/test/PrintAsObjC/emit-objc-header-textually.swift
