[cxx-interop][index] emit symbolic interface files for C++ modules

Author: hyp

include/swift/AST/DiagnosticsFrontend.def

@@ -270,6 +270,10 @@ REMARK(remark_indexing_system_module,none,
        "indexing system module at %0"
        "%select{|; skipping because of a broken swiftinterface}1",
        (StringRef, bool))
+REMARK(remark_emitting_symbolic_interface_module,none,
+       "emitting symbolic interface at %0"
+       "%select{|; skipping because it's up to date}1",
+       (StringRef, bool))
 
 ERROR(error_wrong_number_of_arguments,none,
       "wrong number of '%0' arguments (expected %1, got %2)",

include/swift/AST/PrintOptions.h

@@ -562,6 +562,10 @@ struct PrintOptions {
   /// If false, we print them as ordinary associated types.
   bool PrintPrimaryAssociatedTypes = true;
 
+  /// If true, import and print C++ declarations with symbolic import feature
+  /// enabled.
+  bool PrintSymbolicCXXDecls = false;
+
   /// If this is not \c nullptr then function bodies (including accessors
   /// and constructors) will be printed by this function.
   std::function<void(const ValueDecl *, ASTPrinter &)> FunctionBody;

include/swift/ClangImporter/ClangImporter.h

@@ -555,6 +555,9 @@ class ClangImporter final : public ClangModuleLoader {
   /// Emit diagnostics for declarations named name that are members
   /// of the provided baseType.
   void diagnoseMemberValue(const DeclName &name, const Type &baseType) override;
+
+  /// Enable/disable the symbolic import experimental feature.
+  void enableSymbolicImportFeature(bool isEnabled = true);
 };
 
 ImportDecl *createImportDecl(ASTContext &Ctx, DeclContext *DC, ClangNode ClangN,

include/swift/IDE/ModuleInterfacePrinting.h

@@ -19,6 +19,10 @@
 #include <string>
 #include <vector>
 
+namespace clang {
+class Module;
+}
+
 namespace swift {
 class ASTContext;
 class ASTPrinter;
@@ -68,6 +72,10 @@ void printHeaderInterface(StringRef Filename, ASTContext &Ctx,
 void printSwiftSourceInterface(SourceFile &File, ASTPrinter &Printer,
                                const PrintOptions &Options);
 
+/// Print the symbolic Swift interface for a given imported clang module.
+void printSymbolicSwiftClangModuleInterface(ModuleDecl *M, ASTPrinter &Printer,
+                                            const clang::Module *clangModule);
+
 } // namespace ide
 
 } // namespace swift

lib/ClangImporter/ClangImporter.cpp

@@ -6564,3 +6564,8 @@ CustomRefCountingOperationResult CustomRefCountingOperation::evaluate(
 
   return {CustomRefCountingOperationResult::tooManyFound, nullptr, name};
 }
+
+void ClangImporter::enableSymbolicImportFeature(bool isEnabled) {
+  Impl.importSymbolicCXXDecls = isEnabled;
+  Impl.nameImporter->enableSymbolicImportFeature(isEnabled);
+}

lib/ClangImporter/ImportName.h

@@ -458,6 +458,10 @@ class NameImporter {
                             clang::ObjCInterfaceDecl *classDecl,
                             bool forInstance);
 
+  inline void enableSymbolicImportFeature(bool isEnabled) {
+    importSymbolicCXXDecls = isEnabled;
+  }
+
 private:
   bool enableObjCInterop() const { return swiftCtx.LangOpts.EnableObjCInterop; }
 

lib/IDE/ModuleInterfacePrinting.cpp

@@ -544,6 +544,18 @@ void swift::ide::printModuleInterface(
   auto &SwiftContext = TopLevelMod->getASTContext();
   auto &Importer =
       static_cast<ClangImporter &>(*SwiftContext.getClangModuleLoader());
+  if (Options.PrintSymbolicCXXDecls)
+    Importer.enableSymbolicImportFeature(true);
+  struct SymbolicImportRAII {
+    bool PrintSymbolicCXXDecls;
+    ClangImporter &Importer;
+    SymbolicImportRAII(bool PrintSymbolicCXXDecls, ClangImporter &Importer)
+        : PrintSymbolicCXXDecls(PrintSymbolicCXXDecls), Importer(Importer) {}
+    ~SymbolicImportRAII() {
+      if (PrintSymbolicCXXDecls)
+        Importer.enableSymbolicImportFeature(false);
+    }
+  } deferDisableSymbolicImport(Options.PrintSymbolicCXXDecls, Importer);
 
   auto AdjustedOptions = Options;
   adjustPrintOptions(AdjustedOptions);
@@ -1134,3 +1146,22 @@ void ClangCommentPrinter::updateLastEntityLine(clang::FileID FID,
   if (LineNo > LastEntiyLine)
     LastEntiyLine = LineNo;
 }
+
+void swift::ide::printSymbolicSwiftClangModuleInterface(
+    ModuleDecl *M, ASTPrinter &Printer, const clang::Module *clangModule) {
+  std::string headerComment;
+  llvm::raw_string_ostream(headerComment)
+      << "// Swift interface for " << (clangModule->IsSystem ? "system " : "")
+      << "module '" << clangModule->Name << "'\n";
+  Printer.printText(headerComment);
+
+  ModuleTraversalOptions opts;
+  opts |= ModuleTraversal::VisitSubmodules;
+  auto popts =
+      PrintOptions::printModuleInterface(/*printFullConvention=*/false);
+  popts.PrintSymbolicCXXDecls = true;
+  popts.PrintDocumentationComments = false;
+  popts.PrintRegularClangComments = false;
+  printModuleInterface(M, {}, opts, Printer, popts,
+                       /*SynthesizeExtensions=*/false);
+}

lib/Index/IndexRecord.cpp

@@ -12,6 +12,7 @@
 
 #include "swift/Index/IndexRecord.h"
 #include "swift/AST/ASTContext.h"
+#include "swift/AST/ASTPrinter.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticsFrontend.h"
 #include "swift/AST/Expr.h"
@@ -24,13 +25,15 @@
 #include "swift/AST/Types.h"
 #include "swift/Basic/PathRemapper.h"
 #include "swift/ClangImporter/ClangModule.h"
+#include "swift/IDE/ModuleInterfacePrinting.h"
 #include "swift/Index/Index.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Frontend/CompilerInstance.h"
-#include "clang/Index/IndexingAction.h"
 #include "clang/Index/IndexRecordWriter.h"
 #include "clang/Index/IndexUnitWriter.h"
+#include "clang/Index/IndexingAction.h"
 #include "clang/Lex/Preprocessor.h"
+#include "clang/Serialization/ASTReader.h"
 #include "llvm/Support/Path.h"
 
 using namespace swift;
@@ -393,6 +396,176 @@ emitDataForSwiftSerializedModule(ModuleDecl *module,
                                  const PathRemapper &pathRemapper,
                                  SourceFile *initialFile);
 
+// FIXME (Alex): Share code with importer.
+inline bool requiresCPlusPlus(const clang::Module *module) {
+  // The libc++ modulemap doesn't currently declare the requirement.
+  if (module->getTopLevelModuleName() == "std")
+    return true;
+
+  // Modulemaps often declare the requirement for the top-level module only.
+  if (auto parent = module->Parent) {
+    if (requiresCPlusPlus(parent))
+      return true;
+  }
+
+  return llvm::any_of(module->Requirements, [](clang::Module::Requirement req) {
+    return req.first == "cplusplus";
+  });
+}
+
+static void
+appendSymbolicInterfaceToIndexStorePath(SmallVectorImpl<char> &resultingPath) {
+  llvm::sys::path::append(resultingPath, "interfaces");
+}
+
+static bool initSymbolicInterfaceStorePath(StringRef storePath,
+                                           std::string &error) {
+  using namespace llvm::sys;
+  SmallString<128> subPath = storePath;
+  appendSymbolicInterfaceToIndexStorePath(subPath);
+  std::error_code ec = fs::create_directories(subPath);
+  if (ec) {
+    llvm::raw_string_ostream err(error);
+    err << "failed to create directory '" << subPath << "': " << ec.message();
+    return true;
+  }
+  return false;
+}
+
+static void appendSymbolicInterfaceClangModuleFilename(
+    StringRef filePath, SmallVectorImpl<char> &resultingPath) {
+  llvm::sys::path::append(resultingPath, llvm::sys::path::filename(filePath));
+  StringRef extension = ".symbolicswiftinterface";
+  resultingPath.append(extension.begin(), extension.end());
+}
+
+// FIXME (Alex): Share code with IndexUnitWriter in LLVM after refactoring it.
+static Optional<bool>
+isFileUpToDateForOutputFile(StringRef filePath,
+                            Optional<StringRef> timeCompareFilePath,
+                            std::string &error) {
+  llvm::sys::fs::file_status unitStat;
+  if (std::error_code ec = llvm::sys::fs::status(filePath, unitStat)) {
+    if (ec != std::errc::no_such_file_or_directory) {
+      llvm::raw_string_ostream err(error);
+      err << "could not access path '" << filePath << "': " << ec.message();
+      return {};
+    }
+    return false;
+  }
+
+  if (!timeCompareFilePath)
+    return true;
+
+  llvm::sys::fs::file_status compareStat;
+  if (std::error_code ec =
+          llvm::sys::fs::status(*timeCompareFilePath, compareStat)) {
+    if (ec != std::errc::no_such_file_or_directory) {
+      llvm::raw_string_ostream err(error);
+      err << "could not access path '" << *timeCompareFilePath
+          << "': " << ec.message();
+      return {};
+    }
+    return true;
+  }
+
+  // Return true (unit is up-to-date) if the file to compare is older than the
+  // unit file.
+  return compareStat.getLastModificationTime() <=
+         unitStat.getLastModificationTime();
+}
+
+/// Emit the symbolic swift interface file for an imported Clang module into the
+/// index store directory.
+///
+/// The swift interface file is emitted only when it doesn't exist yet, or when
+/// the PCM for the Clang module has been updated.
+///
+/// System modules without the 'cplusplus' requirement are not emitted.
+static void emitSymbolicInterfaceForClangModule(
+    ClangModuleUnit *clangModUnit, ModuleDecl *M,
+    const clang::Module *clangModule, StringRef indexStorePath,
+    const clang::CompilerInstance &clangCI, DiagnosticEngine &diags) {
+  if (!M->getASTContext().LangOpts.EnableCXXInterop)
+    return;
+  // Skip system modules without an explicit 'cplusplus' requirement.
+  bool isSystem = clangModUnit->isSystemModule();
+  if (isSystem && !requiresCPlusPlus(clangModule))
+    return;
+
+  // Make sure the `interfaces` directory is created.
+  std::string error;
+  if (initSymbolicInterfaceStorePath(indexStorePath, error)) {
+    diags.diagnose(SourceLoc(), diag::error_create_index_dir, error);
+    return;
+  }
+
+  // Determine the output name for the symbolic interface file.
+  clang::serialization::ModuleFile *ModFile =
+      clangCI.getASTReader()->getModuleManager().lookup(
+          clangModule->getASTFile());
+  assert(ModFile && "no module file loaded for module ?");
+  SmallString<128> interfaceOutputPath = indexStorePath;
+  appendSymbolicInterfaceToIndexStorePath(interfaceOutputPath);
+  appendSymbolicInterfaceClangModuleFilename(ModFile->FileName,
+                                             interfaceOutputPath);
+
+  // Check if the symbolic interface file is already up to date.
+  auto upToDate = isFileUpToDateForOutputFile(
+      interfaceOutputPath, StringRef(ModFile->FileName), error);
+  if (!upToDate) {
+    diags.diagnose(SourceLoc(), diag::error_index_failed_status_check, error);
+    return;
+  }
+  if (M->getASTContext().LangOpts.EnableIndexingSystemModuleRemarks) {
+    diags.diagnose(SourceLoc(), diag::remark_emitting_symbolic_interface_module,
+                   interfaceOutputPath, *upToDate);
+  }
+  if (*upToDate)
+    return;
+
+  // Output the interface to a temporary file first.
+  SmallString<128> tempOutputPath;
+  tempOutputPath = llvm::sys::path::parent_path(interfaceOutputPath);
+  llvm::sys::path::append(tempOutputPath,
+                          llvm::sys::path::filename(interfaceOutputPath));
+  tempOutputPath += "-%%%%%%%%";
+  int tempFD;
+  if (llvm::sys::fs::createUniqueFile(tempOutputPath.str(), tempFD,
+                                      tempOutputPath)) {
+    llvm::raw_string_ostream errOS(error);
+    errOS << "failed to create temporary file: " << tempOutputPath;
+    diags.diagnose(SourceLoc(), diag::error_write_index_record, errOS.str());
+    return;
+  }
+
+  llvm::raw_fd_ostream os(tempFD, /*shouldClose=*/true);
+  std::unique_ptr<ASTPrinter> printer;
+  printer.reset(new StreamPrinter(os));
+  ide::printSymbolicSwiftClangModuleInterface(M, *printer, clangModule);
+  os.close();
+
+  if (os.has_error()) {
+    llvm::raw_string_ostream errOS(error);
+    errOS << "failed to write '" << tempOutputPath
+          << "': " << os.error().message();
+    diags.diagnose(SourceLoc(), diag::error_write_index_record, errOS.str());
+    os.clear_error();
+    return;
+  }
+
+  // Move the resulting output to the destination symbolic interface file.
+  std::error_code ec = llvm::sys::fs::rename(
+      /*from=*/tempOutputPath.c_str(), /*to=*/interfaceOutputPath.c_str());
+  if (ec) {
+    llvm::raw_string_ostream errOS(error);
+    errOS << "failed to rename '" << tempOutputPath << "' to '"
+          << interfaceOutputPath << "': " << ec.message();
+    diags.diagnose(SourceLoc(), diag::error_write_index_record, errOS.str());
+    return;
+  }
+}
+
 static void addModuleDependencies(ArrayRef<ImportedModule> imports,
                                   StringRef indexStorePath,
                                   bool indexClangModules,
@@ -444,6 +617,9 @@ static void addModuleDependencies(ArrayRef<ImportedModule> imports,
               if (shouldIndexModule)
                 clang::index::emitIndexDataForModuleFile(clangMod,
                                                          clangCI, unitWriter);
+              // Emit the symbolic interface file in addition to index data.
+              emitSymbolicInterfaceForClangModule(
+                  clangModUnit, mod, clangMod, indexStorePath, clangCI, diags);
             }
           } else {
             // Serialized AST file.

test/Interop/Cxx/symbolic-imports/indexing-emit-libcxx-symbolic-module-interface.swift

@@ -0,0 +1,43 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// Verify that symbolic interfaces are emitted.
+//
+// RUN: %target-swift-frontend %t/test.swift -I %t -c -index-system-modules -index-store-path %t/store -enable-experimental-cxx-interop -Rindexing-system-module 2>&1 | %FileCheck --check-prefix=REMARK_NEW %s
+// RUN: ls %t/store/interfaces | %FileCheck --check-prefix=FILES %s
+// RUN: cat %t/store/interfaces/std* | %FileCheck --check-prefix=CHECK %s
+
+// Verify that symbolic interfaces are not emitted when PCM doesn't change.
+//
+// RUN: %target-swift-frontend %t/test.swift -I %t -c -index-system-modules -index-store-path %t/store -enable-experimental-cxx-interop -Rindexing-system-module 2>&1 | %FileCheck --check-prefix=REMARK_NO_UPDATE %s
+// RUN: ls %t/store/interfaces | %FileCheck --check-prefix=FILES %s
+
+// REQUIRES: OS=macosx
+
+//--- Inputs/module.modulemap
+module CxxModule {
+    header "headerA.h"
+    requires cplusplus
+}
+
+//--- Inputs/headerA.h
+
+int freeFunction(int x, int y);
+
+//--- test.swift
+
+import CxxStdlib
+import CxxModule
+import Foundation
+
+// REMARK_NEW: remark: emitting symbolic interface at {{.*}}/interfaces/std-{{.*}}.pcm.symbolicswiftinterface{{$}}
+// REMARK_NEW: remark: emitting symbolic interface at {{.*}}/interfaces/CxxModule-{{.*}}.pcm.symbolicswiftinterface{{$}}
+
+// REMARK_NO_UPDATE: remark: emitting symbolic interface at {{.*}}/interfaces/std-{{.*}}.pcm.symbolicswiftinterface; skipping because it's up to date{{$}}
+// REMARK_NO_UPDATE: remark: emitting symbolic interface at {{.*}}/interfaces/CxxModule-{{.*}}.pcm.symbolicswiftinterface; skipping because it's up to date{{$}}
+
+// FILES: CxxModule-{{.*}}.pcm.symbolicswiftinterface
+// FILES: std-{{.*}}.pcm.symbolicswiftinterface
+// FILES-NOT: Foundation*
+
+// CHECK: // Swift interface for system module 'std'