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

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 translate each modular import included in such a header with
a set of equivalent textual imports.

Author: Nuri Amari

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);

include/swift/Option/Options.td

@@ -543,6 +543,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,

include/swift/PrintAsClang/PrintAsClang.h

@@ -21,6 +21,7 @@ namespace swift {
 class IRGenOptions;
 class ModuleDecl;
 class ValueDecl;
+class FrontendOptions;
 
 /// Print the exposed declarations in a module into a Clang header.
 ///
@@ -35,7 +36,8 @@ class ValueDecl;
 bool printAsClangHeader(raw_ostream &out, ModuleDecl *M,
                         StringRef bridgingHeader,
                         bool ExposePublicDeclsInClangHeader,
-                        const IRGenOptions &irGenOpts);
+                        const IRGenOptions &irGenOpts,
+                        const FrontendOptions &frontendOpts);
 }
 
 #endif

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);
 

lib/FrontendTool/FrontendTool.cpp

@@ -182,13 +182,15 @@ static bool writeSIL(SILModule &SM, const PrimarySpecificPaths &PSPs,
 static bool printAsClangHeaderIfNeeded(StringRef outputPath, ModuleDecl *M,
                                        StringRef bridgingHeader,
                                        bool ExposePublicDeclsInClangHeader,
-                                       const IRGenOptions &irGenOpts) {
+                                       const IRGenOptions &irGenOpts,
+                                       const FrontendOptions &frontendOpts) {
   if (outputPath.empty())
     return false;
   return withOutputFile(
       M->getDiags(), outputPath, [&](raw_ostream &out) -> bool {
         return printAsClangHeader(out, M, bridgingHeader,
-                                  ExposePublicDeclsInClangHeader, irGenOpts);
+                                  ExposePublicDeclsInClangHeader, irGenOpts,
+                                  frontendOpts);
       });
 }
 
@@ -937,7 +939,8 @@ static bool emitAnyWholeModulePostTypeCheckSupplementaryOutputs(
     hadAnyError |= printAsClangHeaderIfNeeded(
         Invocation.getClangHeaderOutputPathForAtMostOnePrimary(),
         Instance.getMainModule(), BridgingHeaderPathForPrint,
-        opts.ExposePublicDeclsInClangHeader, Invocation.getIRGenOptions());
+        opts.ExposePublicDeclsInClangHeader, Invocation.getIRGenOptions(),
+        opts);
   }
 
   // Only want the header if there's been any errors, ie. there's not much

lib/PrintAsClang/PrintAsClang.cpp

@@ -20,7 +20,9 @@
 #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 "llvm/Support/raw_ostream.h"
@@ -393,9 +395,90 @@ static int compareImportModulesByName(const ImportModuleTy *left,
   return 1;
 }
 
+// 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<32>, 10> &requiredTextualIncludes) {
+
+  auto addHeader = [&](const clang::Module *module, StringRef header) {
+    llvm::SmallString<32> fullHeaderName = header;
+    if (clangModule->IsFramework) {
+      // Frameworks store their headers in an explicit header directory
+      // Transform "Headers/Foundation.h" -> "Foundation/Foundation.h"
+      llvm::sys::path::replace_path_prefix(fullHeaderName, "Headers",
+                                           clangModule->Name);
+    } else {
+      // Prepend the name of the directory containing the module to the header
+      // include
+      SmallString<32> newHeaderName =
+          *(++llvm::sys::path::rbegin(clangModule->PresumedModuleMapFile));
+      llvm::sys::path::append(newHeaderName, header);
+      fullHeaderName = newHeaderName;
+    }
+    requiredTextualIncludes.insert(fullHeaderName);
+  };
+
+  for (clang::Module::HeaderKind headerKind :
+       {clang::Module::HK_Normal, clang::Module::HK_Private}) {
+    for (const clang::Module::Header &header :
+         clangModule->Headers[headerKind]) {
+      addHeader(clangModule, header.PathRelativeToRootModuleDirectory);
+    }
+  }
+
+  if (clang::Module::Header umbrellaHeader = clangModule->getUmbrellaHeader()) {
+    addHeader(clangModule, 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)) {
+
+        // Computer 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(clangModule, relativeHeaderPath);
+      }
+    }
+  }
+
+  for (auto submodule : clangModule->submodules()) {
+    collectClangModuleHeaderIncludes(submodule, fileManager,
+                                     requiredTextualIncludes);
+  }
+}
+
 static void writeImports(raw_ostream &out,
                          llvm::SmallPtrSetImpl<ImportModuleTy> &imports,
-                         ModuleDecl &M, StringRef bridgingHeader) {
+                         ModuleDecl &M, StringRef bridgingHeader,
+                         const FrontendOptions &frontendOpts) {
   out << "#if __has_feature(modules)\n";
 
   out << "#if __has_warning(\"-Watimport-in-framework-header\")\n"
@@ -417,6 +500,11 @@ static void writeImports(raw_ostream &out,
     return import == importer->getImportedHeaderModule();
   };
 
+  clang::FileSystemOptions fileSystemOptions;
+  clang::FileManager fileManager{fileSystemOptions};
+
+  llvm::SmallSet<llvm::SmallString<32>, 10> requiredTextualIncludes;
+
   // Track printed names to handle overlay modules.
   llvm::SmallPtrSet<Identifier, 8> seenImports;
   bool includeUnderlying = false;
@@ -427,18 +515,39 @@ static void writeImports(raw_ostream &out,
         includeUnderlying = true;
         continue;
       }
-      if (seenImports.insert(Name).second)
+      if (seenImports.insert(Name).second) {
         out << "@import " << Name.str() << ";\n";
+        if (frontendOpts.EmitObjCHeaderWithTextualImports) {
+          if (const clang::Module *underlyingClangModule =
+                  swiftModule->findUnderlyingClangModule()) {
+            collectClangModuleHeaderIncludes(underlyingClangModule, fileManager,
+                                             requiredTextualIncludes);
+          }
+        }
+      }
     } else {
       const auto *clangModule = import.get<const clang::Module *>();
       assert(clangModule->isSubModule() &&
              "top-level modules should use a normal swift::ModuleDecl");
       out << "@import ";
       ModuleDecl::ReverseFullNameIterator(clangModule).printForward(out);
       out << ";\n";
+
+      if (frontendOpts.EmitObjCHeaderWithTextualImports) {
+        collectClangModuleHeaderIncludes(clangModule, fileManager,
+                                         requiredTextualIncludes);
+      }
     }
   }
 
+  if (frontendOpts.EmitObjCHeaderWithTextualImports) {
+    out << "#else\n";
+    for (auto header : requiredTextualIncludes) {
+      out << "#if __has_include(<" << header << ">)\n";
+      out << "#import <" << header << ">\n";
+      out << "#endif\n";
+    }
+  }
   out << "#endif\n\n";
 
   if (includeUnderlying) {
@@ -504,7 +613,8 @@ getModuleContentsCxxString(ModuleDecl &M,
 bool swift::printAsClangHeader(raw_ostream &os, ModuleDecl *M,
                                StringRef bridgingHeader,
                                bool ExposePublicDeclsInClangHeader,
-                               const IRGenOptions &irGenOpts) {
+                               const IRGenOptions &irGenOpts,
+                               const FrontendOptions &frontendOpts) {
   llvm::PrettyStackTraceString trace("While generating Clang header");
 
   SwiftToClangInteropContext interopContext(*M, irGenOpts);
@@ -514,8 +624,8 @@ 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); });
   writePostImportPrologue(os, *M);
   emitObjCConditional(os, [&] { os << objcModuleContents.str(); });
   emitCxxConditional(os, [&] {

test/PrintAsObjC/textual-imports.swift

@@ -0,0 +1,26 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/../Inputs/clang-importer-sdk -I %t) -typecheck -emit-objc-header-path %t/textual-imports.h -emit-objc-header-textually %s 
+// RUN: %FileCheck %s < %t/textual-imports.h
+// RUN: %check-in-clang %t/textual-imports.h
+
+import Foundation
+
+public class HelloWorld: NSObject {
+  @objc public func sayHello() {
+    print("Hello, World!")
+  }
+}
+
+// CHECK:      #if __has_feature(modules)
+// CHECK-NEXT: #if __has_warning("-Watimport-in-framework-header")
+// CHECK-NEXT: #pragma clang diagnostic ignored "-Watimport-in-framework-header"
+// CHECK-NEXT: #endif
+// CHECK-NEXT: @import ObjectiveC;
+// CHECK-NEXT: #else
+// CHECK-NEXT: #if __has_include(<objc/objc.h>)
+// CHECK-NEXT: #import <objc/objc.h>
+// CHECK-NEXT: #endif
+// CHECK-NEXT: #if __has_include(<objc/NSObject.h>)
+// CHECK-NEXT: #import <objc/NSObject.h>
+// CHECK-NEXT: #endif
+// CHECK-NEXT: #endif