[clang][modules] Track affecting modules

[jansvoboda11]

Summary

When compiling a module, its semantics and Clang's behavior are affected by other modules. These modules are typically the imported ones. However, during implicit build, some modules end up being compiled and read without being actually imported. This patch starts tracking such modules and serializing them into .pcm files. This enables the dependency scanner to construct explicit compilations that mimic implicit build.

[benlangmuir]

clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp

284

If using eager loading, this will cause us to load the module, right? Does that behaviour match the implicit build?

clang/test/ClangScanDeps/modules-incomplete-umbrella.c

83

The test should probably cover the imports in the command-lines.

[jansvoboda11]

clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp

284

That's correct. The implicit build does the same.

clang/test/ClangScanDeps/modules-incomplete-umbrella.c

83

Most -fmodule-file= checks were removed in D132066, since these are likely to change in the future, and I'm okay with relying on "clang-module-deps". I can see the argument that in this particular case the dependencies are not ordinary imports, but somewhat of an edge case, so I'm fine with adding the checks.

[benlangmuir]

clang/test/ClangScanDeps/modules-incomplete-umbrella.c

83

I'd prefer to add the checks in this specific case. I agree it's not relevant to most other tests.

[jansvoboda11]

Add -fmodule-file= assertions

[jansvoboda11]

Backslashes in tests on Windows

clang/include/clang/Basic/Module.h

public:
 
   /// The location of the inferred submodule.
   SourceLocation InferredSubmoduleLoc;
 
   /// The set of modules imported by this module, and on which this
   /// module depends.
   llvm::SmallSetVector<Module *, 2> Imports;
 
+  /// The set of top-level modules that affected the compilation of this module,
+  /// but were not imported.
+  llvm::SmallSetVector<Module *, 2> AffectingModules;
+
   /// Describes an exported module.
   ///
   /// The pointer is the module being re-exported, while the bit will be true
   /// to indicate that this is a wildcard export.
   using ExportDecl = llvm::PointerIntPair<Module *, 1, bool>;
 
   /// The set of export declarations.
   SmallVector<ExportDecl, 2> Exports;

clang/include/clang/Lex/ModuleLoader.h

enum LoadResultKind {
     // The module exists but cannot be imported due to a configuration mismatch.
     ConfigMismatch,
   };
   llvm::PointerIntPair<Module *, 2, LoadResultKind> Storage;
 
   ModuleLoadResult() = default;
   ModuleLoadResult(Module *M) : Storage(M, Normal) {}
   ModuleLoadResult(LoadResultKind Kind) : Storage(nullptr, Kind) {}
+  ModuleLoadResult(Module *M, LoadResultKind Kind) : Storage(M, Kind) {}
+
+  operator bool() const {
+    return Storage.getInt() == Normal && Storage.getPointer();
+  }
 
   operator Module *() const { return Storage.getPointer(); }
 
   /// Determines whether this is a normal return, whether or not loading the
   /// module was successful.
   bool isNormal() const { return Storage.getInt() == Normal; }
 
   /// Determines whether the module, which failed to load, was

clang/include/clang/Lex/Preprocessor.h

private:
 
   /// The current submodule state. Will be \p NullSubmoduleState if we're not
   /// in a submodule.
   SubmoduleState *CurSubmoduleState;
 
   /// The files that have been included.
   IncludedFilesSet IncludedFiles;
 
+  /// The set of top-level modules that affected preprocessing, but were not
+  /// imported.
+  llvm::SmallSetVector<Module *, 2> AffectingModules;
+
   /// The set of known macros exported from modules.
   llvm::FoldingSet<ModuleMacro> ModuleMacros;
 
   /// The names of potential module macros that we've not yet processed.
   llvm::SmallVector<const IdentifierInfo *, 32> PendingModuleMacroNames;
 
   /// The list of module macros, for each identifier, that are not overridden by
   /// any other module macro.
public:
   macros(bool IncludeExternalMacros = true) const {
     macro_iterator begin = macro_begin(IncludeExternalMacros);
     macro_iterator end = macro_end(IncludeExternalMacros);
     return llvm::make_range(begin, end);
   }
 
   /// \}
 
+  /// Get the set of top-level modules that affected preprocessing, but were not
+  /// imported.
+  const llvm::SmallSetVector<Module *, 2> &getAffectingModules() const {
+    return AffectingModules;
+  }
+
   /// Mark the file as included.
   /// Returns true if this is the first time the file was included.
   bool markIncluded(const FileEntry *File) {
     HeaderInfo.getFileInfo(File);
     return IncludedFiles.insert(File).second;
   }
 
   /// Return true if this header has already been included.

clang/include/clang/Serialization/ASTBitCodes.h

enum SubmoduleRecordTypes {
 
   /// Specifies some declarations with initializers that must be
   /// emitted to initialize the module.
   SUBMODULE_INITIALIZERS = 16,
 
   /// Specifies the name of the module that will eventually
   /// re-export the entities in this module.
   SUBMODULE_EXPORT_AS = 17,
+
+  /// Specifies affecting modules that were not imported.
+  SUBMODULE_AFFECTING_MODULES = 18,
 };
 
 /// Record types used within a comments block.
 enum CommentRecordTypes { COMMENTS_RAW_COMMENT = 0 };
 
 /// \defgroup ASTAST AST file AST constants
 ///
 /// The constants in this group describe various components of the

clang/include/clang/Serialization/ASTReader.h

private:
   struct UnresolvedModuleRef {
     /// The file in which this module resides.
     ModuleFile *File;
 
     /// The module that is importing or exporting.
     Module *Mod;
 
     /// The kind of module reference.
-    enum { Import, Export, Conflict } Kind;
+    enum { Import, Export, Conflict, Affecting } Kind;
 
     /// The local ID of the module that is being exported.
     unsigned ID;
 
     /// Whether this is a wildcard export.
     unsigned IsWildcard : 1;
 
     /// String data.

clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h

private:
   /// Traverses the previously collected direct modular dependencies to discover
   /// transitive modular dependencies and fills the parent \c ModuleDepCollector
   /// with both.
   ModuleID handleTopLevelModule(const Module *M);
   void addAllSubmoduleDeps(const Module *M, ModuleDeps &MD,
                            llvm::DenseSet<const Module *> &AddedModules);
   void addModuleDep(const Module *M, ModuleDeps &MD,
                     llvm::DenseSet<const Module *> &AddedModules);
+
+  /// Traverses the affecting modules and updates \c MD with references to the
+  /// parent \c ModuleDepCollector info.
+  void addAllAffectingModules(const Module *M, ModuleDeps &MD,
+                              llvm::DenseSet<const Module *> &AddedModules);
+  void addAffectingModule(const Module *M, ModuleDeps &MD,
+                          llvm::DenseSet<const Module *> &AddedModules);
 };
 
 /// Collects modular and non-modular dependencies of the main file by attaching
 /// \c ModuleDepCollectorPP to the preprocessor.
 class ModuleDepCollector final : public DependencyCollector {
 public:
   ModuleDepCollector(std::unique_ptr<DependencyOutputOptions> Opts,
                      CompilerInstance &ScanInstance, DependencyConsumer &C,

clang/lib/Frontend/CompilerInstance.cpp

if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
       // this missing submodule and recover by forgetting that we ever saw
       // this submodule.
       // FIXME: Should we detect this at module load time? It seems fairly
       // expensive (and rare).
       getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
         << Module->getFullModuleName()
         << SourceRange(Path.front().second, Path.back().second);
 
-      return ModuleLoadResult::MissingExpected;
+      return ModuleLoadResult(Module, ModuleLoadResult::MissingExpected);
     }
 
     // Check whether this module is available.
     if (Preprocessor::checkModuleIsAvailable(getLangOpts(), getTarget(),
                                              getDiagnostics(), Module)) {
       getDiagnostics().Report(ImportLoc, diag::note_module_import_here)
         << SourceRange(Path.front().second, Path.back().second);
       LastModuleImportLoc = ImportLoc;

clang/lib/Lex/HeaderSearch.cpp

if (!RequestingModule->directlyUses(Module.getModule())) {
       // ShouldEnterIncludeFile()), so the builtin header may have been
       // "claimed" by an unrelated module. This shouldn't prevent us from
       // including the builtin header textually in this module.
       if (HS.getModuleMap().isBuiltinHeader(File)) {
         if (SuggestedModule)
           *SuggestedModule = ModuleMap::KnownHeader();
         return true;
       }
+      // TODO: Add this module (or just its module map file) into something like
+      // `RequestingModule->AffectingModules`.
       return false;
     }
   }
 
   if (SuggestedModule)
     *SuggestedModule = (Module.getRole() & ModuleMap::TextualHeader)
                            ? ModuleMap::KnownHeader()
                            : Module;

clang/lib/Lex/PPDirectives.cpp

ModuleLoadResult Imported = TheModuleLoader.loadModule(
         IncludeTok.getLocation(), Path, Module::Hidden,
         /*IsInclusionDirective=*/true);
     assert((Imported == nullptr || Imported == SuggestedModule.getModule()) &&
            "the imported module is different than the suggested one");
 
     if (Imported) {
       Action = Import;
     } else if (Imported.isMissingExpected()) {
+      Module *M = static_cast<Module *>(Imported)->getTopLevelModule();
+      if (!BuildingSubmoduleStack.empty()) {
+        if (Imported != BuildingSubmoduleStack.back().M)
+          BuildingSubmoduleStack.back().M->AffectingModules.insert(M);
+      } else {
+        AffectingModules.insert(M);
+      }
       // We failed to find a submodule that we assumed would exist (because it
       // was in the directory of an umbrella header, for instance), but no
       // actual module containing it exists (because the umbrella header is
       // incomplete).  Treat this as a textual inclusion.
       SuggestedModule = ModuleMap::KnownHeader();
       SM = nullptr;
     } else if (Imported.isConfigMismatch()) {
       // On a configuration mismatch, enter the header textually. We still know

clang/lib/Serialization/ASTReader.cpp

case UnresolvedModuleRef::Conflict:
       }
       continue;
 
     case UnresolvedModuleRef::Import:
       if (ResolvedMod)
         Unresolved.Mod->Imports.insert(ResolvedMod);
       continue;
 
+    case UnresolvedModuleRef::Affecting:
+      if (ResolvedMod)
+        Unresolved.Mod->AffectingModules.insert(ResolvedMod);
+      continue;
+
     case UnresolvedModuleRef::Export:
       if (ResolvedMod || Unresolved.IsWildcard)
         Unresolved.Mod->Exports.push_back(
           Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
       continue;
     }
   }
   UnresolvedModuleRefs.clear();
case SUBMODULE_IMPORTS:
         Unresolved.Mod = CurrentModule;
         Unresolved.ID = Record[Idx];
         Unresolved.Kind = UnresolvedModuleRef::Import;
         Unresolved.IsWildcard = false;
         UnresolvedModuleRefs.push_back(Unresolved);
       }
       break;
 
+    case SUBMODULE_AFFECTING_MODULES:
+      for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
+        UnresolvedModuleRef Unresolved;
+        Unresolved.File = &F;
+        Unresolved.Mod = CurrentModule;
+        Unresolved.ID = Record[Idx];
+        Unresolved.Kind = UnresolvedModuleRef::Affecting;
+        Unresolved.IsWildcard = false;
+        UnresolvedModuleRefs.push_back(Unresolved);
+      }
+      break;
+
     case SUBMODULE_EXPORTS:
       for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
         UnresolvedModuleRef Unresolved;
         Unresolved.File = &F;
         Unresolved.Mod = CurrentModule;
         Unresolved.ID = Record[Idx];
         Unresolved.Kind = UnresolvedModuleRef::Export;
         Unresolved.IsWildcard = Record[Idx + 1];

clang/lib/Serialization/ASTWriter.cpp

#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
   BLOCK(SUBMODULE_BLOCK);
   RECORD(SUBMODULE_METADATA);
   RECORD(SUBMODULE_DEFINITION);
   RECORD(SUBMODULE_UMBRELLA_HEADER);
   RECORD(SUBMODULE_HEADER);
   RECORD(SUBMODULE_TOPHEADER);
   RECORD(SUBMODULE_UMBRELLA_DIR);
   RECORD(SUBMODULE_IMPORTS);
+  RECORD(SUBMODULE_AFFECTING_MODULES);
   RECORD(SUBMODULE_EXPORTS);
   RECORD(SUBMODULE_REQUIRES);
   RECORD(SUBMODULE_EXCLUDED_HEADER);
   RECORD(SUBMODULE_LINK_LIBRARY);
   RECORD(SUBMODULE_CONFIG_MACRO);
   RECORD(SUBMODULE_CONFLICT);
   RECORD(SUBMODULE_PRIVATE_HEADER);
   RECORD(SUBMODULE_TEXTUAL_HEADER);
while (!Q.empty()) {
     // Emit the imports.
     if (!Mod->Imports.empty()) {
       RecordData Record;
       for (auto *I : Mod->Imports)
         Record.push_back(getSubmoduleID(I));
       Stream.EmitRecord(SUBMODULE_IMPORTS, Record);
     }
 
+    // Emit the modules affecting compilation that were not imported.
+    if (!Mod->AffectingModules.empty()) {
+      RecordData Record;
+      for (auto *I : Mod->AffectingModules)
+        Record.push_back(getSubmoduleID(I));
+      Stream.EmitRecord(SUBMODULE_AFFECTING_MODULES, Record);
+    }
+
     // Emit the exports.
     if (!Mod->Exports.empty()) {
       RecordData Record;
       for (const auto &E : Mod->Exports) {
         // FIXME: This may fail; we don't require that all exported modules
         // are local or imported.
         Record.push_back(getSubmoduleID(E.getPointer()));
         Record.push_back(E.getInt());

clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp

void ModuleDepCollectorPP::EndOfMainFile() {
   FileID MainFileID = MDC.ScanInstance.getSourceManager().getMainFileID();
   MDC.MainFile = std::string(MDC.ScanInstance.getSourceManager()
                                  .getFileEntryForID(MainFileID)
                                  ->getName());
 
   if (!MDC.ScanInstance.getPreprocessorOpts().ImplicitPCHInclude.empty())
     MDC.addFileDep(MDC.ScanInstance.getPreprocessorOpts().ImplicitPCHInclude);
 
+  for (const Module *M :
+       MDC.ScanInstance.getPreprocessor().getAffectingModules())
+    if (!MDC.isPrebuiltModule(M))
+      DirectModularDeps.insert(M);
+
   for (const Module *M : DirectModularDeps) {
     // A top-level module might not be actually imported as a module when
     // -fmodule-name is used to compile a translation unit that imports this
     // module. In that case it can be skipped. The appropriate header
     // dependencies will still be reported as expected.
     if (!M->getASTFile())
       continue;
     handleTopLevelModule(M);
ModuleID ModuleDepCollectorPP::handleTopLevelModule(const Module *M) {
   // Add direct prebuilt module dependencies now, so that we can use them when
   // creating a CompilerInvocation and computing context hash for this
   // ModuleDeps instance.
   // TODO: Squash these.
   llvm::DenseSet<const Module *> SeenModules;
   addAllSubmodulePrebuiltDeps(M, MD, SeenModules);
   llvm::DenseSet<const Module *> AddedModules;
   addAllSubmoduleDeps(M, MD, AddedModules);
+  llvm::DenseSet<const Module *> ProcessedModules;
+  addAllAffectingModules(M, MD, ProcessedModules);
 
   MD.BuildInvocation = MDC.makeInvocationForModuleBuildWithoutOutputs(
       MD, [&](CompilerInvocation &BuildInvocation) {
         if (MDC.OptimizeArgs)
           optimizeHeaderSearchOpts(BuildInvocation.getHeaderSearchOpts(),
                                    *MDC.ScanInstance.getASTReader(), *MF);
       });
 
if (Import->getTopLevelModule() != M->getTopLevelModule() &&
         !MDC.isPrebuiltModule(Import)) {
       ModuleID ImportID = handleTopLevelModule(Import->getTopLevelModule());
       if (AddedModules.insert(Import->getTopLevelModule()).second)
         MD.ClangModuleDeps.push_back(ImportID);
     }
   }
 }
 
+void ModuleDepCollectorPP::addAllAffectingModules(
+    const Module *M, ModuleDeps &MD,
+    llvm::DenseSet<const Module *> &AddedModules) {
+  addAffectingModule(M, MD, AddedModules);
+
+  for (const Module *SubM : M->submodules())
+    addAllAffectingModules(SubM, MD, AddedModules);
+}
+
+void ModuleDepCollectorPP::addAffectingModule(
+    const Module *M, ModuleDeps &MD,
+    llvm::DenseSet<const Module *> &AddedModules) {
+  for (const Module *Affecting : M->AffectingModules) {
+    assert(Affecting == Affecting->getTopLevelModule() &&
+           "Not quite import not top-level module");
+    if (Affecting != M->getTopLevelModule() &&
+        !MDC.isPrebuiltModule(Affecting)) {
+      ModuleID ImportID = handleTopLevelModule(Affecting);
+      if (AddedModules.insert(Affecting).second)
+        MD.ClangModuleDeps.push_back(ImportID);
+    }
+  }
+}
+
 ModuleDepCollector::ModuleDepCollector(
     std::unique_ptr<DependencyOutputOptions> Opts,
     CompilerInstance &ScanInstance, DependencyConsumer &C,
     CompilerInvocation &&OriginalCI, bool OptimizeArgs, bool EagerLoadModules)
     : ScanInstance(ScanInstance), Consumer(C), Opts(std::move(Opts)),
       OriginalInvocation(std::move(OriginalCI)), OptimizeArgs(OptimizeArgs),
       EagerLoadModules(EagerLoadModules) {}
 

clang/test/ClangScanDeps/modules-incomplete-umbrella.c

+// This test checks that modules loaded during compilation (but not imported)
+// are still reported as dependencies.
+
+// RUN: rm -rf %t && mkdir %t
+// RUN: split-file %s %t
+
+//--- frameworks/FW.framework/Modules/module.modulemap
+framework module FW {
+  umbrella header "FW.h"
+  module * { export * }
+}
+//--- frameworks/FW.framework/Headers/FW.h
+//--- frameworks/FW.framework/Modules/module.private.modulemap
+framework module FW_Private {
+  umbrella header "FW_Private.h"
+  module * { export * }
+}
+//--- frameworks/FW.framework/PrivateHeaders/FW_Private.h
+#include "One.h"
+//--- frameworks/FW.framework/PrivateHeaders/One.h
+//--- frameworks/FW.framework/PrivateHeaders/Two.h
+
+// Let's check we report the non-imported modular dependencies for a translation unit.
+
+//--- from_tu.cdb.json.template
+[{
+  "file": "DIR/from_tu.m",
+  "directory": "DIR",
+  "command": "clang -fmodules -fmodules-cache-path=DIR/cache -iframework DIR/frameworks -c DIR/from_tu.m -o DIR/from_tu.o"
+}]
+//--- from_tu.m
+#include "FW/FW.h"
+#include "FW/Two.h"
+
+// RUN: sed -e "s|DIR|%/t|g" %t/from_tu.cdb.json.template > %t/from_tu.cdb.json
+// RUN: clang-scan-deps -compilation-database %t/from_tu.cdb.json -format experimental-full > %t/from_tu_result.json
+// RUN: cat %t/from_tu_result.json | sed 's:\\\\\?:/:g' | FileCheck %s -DPREFIX=%/t --check-prefixes=CHECK_TU
+// CHECK_TU:      {
+// CHECK_TU-NEXT:   "modules": [
+// CHECK_TU-NEXT:     {
+// CHECK_TU-NEXT:       "clang-module-deps": [],
+// CHECK_TU-NEXT:       "clang-modulemap-file": "[[PREFIX]]/frameworks/FW.framework/Modules/module.modulemap",
+// CHECK_TU-NEXT:       "command-line": [
+// CHECK_TU:            ],
+// CHECK_TU-NEXT:       "context-hash": "{{.*}}",
+// CHECK_TU-NEXT:       "file-deps": [
+// CHECK_TU-NEXT:         "[[PREFIX]]/frameworks/FW.framework/Headers/FW.h",
+// CHECK_TU-NEXT:         "[[PREFIX]]/frameworks/FW.framework/Modules/module.modulemap",
+// CHECK_TU-NEXT:         "[[PREFIX]]/frameworks/FW.framework/Modules/module.private.modulemap"
+// CHECK_TU-NEXT:       ],
+// CHECK_TU-NEXT:       "name": "FW"
+// CHECK_TU-NEXT:     },
+// CHECK_TU-NEXT:     {
+// CHECK_TU-NEXT:       "clang-module-deps": [],
+// CHECK_TU-NEXT:       "clang-modulemap-file": "[[PREFIX]]/frameworks/FW.framework/Modules/module.private.modulemap",
+// CHECK_TU-NEXT:       "command-line": [
+// CHECK_TU:            ],
+// CHECK_TU-NEXT:       "context-hash": "{{.*}}",
+// CHECK_TU-NEXT:       "file-deps": [
+// CHECK_TU-NEXT:         "[[PREFIX]]/frameworks/FW.framework/Modules/module.modulemap",
+// CHECK_TU-NEXT:         "[[PREFIX]]/frameworks/FW.framework/Modules/module.private.modulemap",
+// CHECK_TU-NEXT:         "[[PREFIX]]/frameworks/FW.framework/PrivateHeaders/FW_Private.h",
+// CHECK_TU-NEXT:         "[[PREFIX]]/frameworks/FW.framework/PrivateHeaders/One.h"
+// CHECK_TU-NEXT:       ],
+// CHECK_TU-NEXT:       "name": "FW_Private"
+// CHECK_TU-NEXT:     }
+// CHECK_TU-NEXT:   ],
+// CHECK_TU-NEXT:   "translation-units": [
+// CHECK_TU-NEXT:     {
+// CHECK_TU-NEXT:       "clang-context-hash": "{{.*}}",
+// CHECK_TU-NEXT:       "clang-module-deps": [
+// CHECK_TU-NEXT:         {
+// CHECK_TU-NEXT:           "context-hash": "{{.*}}",
+// CHECK_TU-NEXT:           "module-name": "FW"
+// CHECK_TU-NEXT:         },
+// CHECK_TU-NEXT:         {
+// CHECK_TU-NEXT:           "context-hash": "{{.*}}",
+// CHECK_TU-NEXT:           "module-name": "FW_Private"
+// CHECK_TU-NEXT:         }
+// CHECK_TU-NEXT:       ],
+// CHECK_TU-NEXT:       "command-line": [
+// CHECK_TU:              "-fmodule-file={{.*}}/FW-{{.*}}.pcm"
+// CHECK_TU:              "-fmodule-file={{.*}}/FW_Private-{{.*}}.pcm"
+// CHECK_TU:            ],
+// CHECK_TU-NEXT:       "file-deps": [
+// CHECK_TU-NEXT:         "[[PREFIX]]/from_tu.m",
+// CHECK_TU-NEXT:         "[[PREFIX]]/frameworks/FW.framework/PrivateHeaders/Two.h"
+// CHECK_TU-NEXT:       ],
+// CHECK_TU-NEXT:       "input-file": "[[PREFIX]]/from_tu.m"
+// CHECK_TU-NEXT:     }
+// CHECK_TU-NEXT:   ]
+// CHECK_TU-NEXT: }
+
+// RUN: %deps-to-rsp %t/from_tu_result.json --module-name=FW > %t/FW.cc1.rsp
+// RUN: %deps-to-rsp %t/from_tu_result.json --module-name=FW_Private > %t/FW_Private.cc1.rsp
+// RUN: %deps-to-rsp %t/from_tu_result.json --tu-index=0 > %t/tu.rsp
+// RUN: %clang @%t/FW.cc1.rsp
+// RUN: %clang @%t/FW_Private.cc1.rsp
+// RUN: %clang @%t/tu.rsp
+
+// Now let's check we report the dependencies for modules as well.
+
+//--- from_module.cdb.json.template
+[{
+  "file": "DIR/from_module.m",
+  "directory": "DIR",
+  "command": "clang -fmodules -fmodules-cache-path=DIR/cache -iframework DIR/frameworks -c DIR/from_module.m -o DIR/from_module.o"
+}]
+//--- module.modulemap
+module Mod { header "Mod.h" }
+//--- Mod.h
+#include "FW/FW.h"
+#include "FW/Two.h"
+//--- from_module.m
+#include "Mod.h"
+
+// RUN: sed -e "s|DIR|%/t|g" %t/from_module.cdb.json.template > %t/from_module.cdb.json
+// RUN: clang-scan-deps -compilation-database %t/from_module.cdb.json -format experimental-full > %t/from_module_result.json
+// RUN: cat %t/from_module_result.json | sed 's:\\\\\?:/:g' | FileCheck %s -DPREFIX=%/t --check-prefixes=CHECK_MODULE
+// CHECK_MODULE:      {
+// CHECK_MODULE-NEXT:   "modules": [
+// CHECK_MODULE-NEXT:     {
+// CHECK_MODULE-NEXT:       "clang-module-deps": [],
+// CHECK_MODULE-NEXT:       "clang-modulemap-file": "[[PREFIX]]/frameworks/FW.framework/Modules/module.modulemap",
+// CHECK_MODULE-NEXT:       "command-line": [
+// CHECK_MODULE:            ],
+// CHECK_MODULE-NEXT:       "context-hash": "{{.*}}",
+// CHECK_MODULE-NEXT:       "file-deps": [
+// CHECK_MODULE-NEXT:         "[[PREFIX]]/frameworks/FW.framework/Headers/FW.h",
+// CHECK_MODULE-NEXT:         "[[PREFIX]]/frameworks/FW.framework/Modules/module.modulemap",
+// CHECK_MODULE-NEXT:         "[[PREFIX]]/frameworks/FW.framework/Modules/module.private.modulemap"
+// CHECK_MODULE-NEXT:       ],
+// CHECK_MODULE-NEXT:       "name": "FW"
+// CHECK_MODULE-NEXT:     },
+// CHECK_MODULE-NEXT:     {
+// CHECK_MODULE-NEXT:       "clang-module-deps": [],
+// CHECK_MODULE-NEXT:       "clang-modulemap-file": "[[PREFIX]]/frameworks/FW.framework/Modules/module.private.modulemap",
+// CHECK_MODULE-NEXT:       "command-line": [
+// CHECK_MODULE:            ],
+// CHECK_MODULE-NEXT:       "context-hash": "{{.*}}",
+// CHECK_MODULE-NEXT:       "file-deps": [
+// CHECK_MODULE-NEXT:         "[[PREFIX]]/frameworks/FW.framework/Modules/module.modulemap",
+// CHECK_MODULE-NEXT:         "[[PREFIX]]/frameworks/FW.framework/Modules/module.private.modulemap",
+// CHECK_MODULE-NEXT:         "[[PREFIX]]/frameworks/FW.framework/PrivateHeaders/FW_Private.h",
+// CHECK_MODULE-NEXT:         "[[PREFIX]]/frameworks/FW.framework/PrivateHeaders/One.h"
+// CHECK_MODULE-NEXT:       ],
+// CHECK_MODULE-NEXT:       "name": "FW_Private"
+// CHECK_MODULE-NEXT:     },
+// CHECK_MODULE-NEXT:     {
+// CHECK_MODULE-NEXT:       "clang-module-deps": [
+// CHECK_MODULE-NEXT:         {
+// CHECK_MODULE-NEXT:           "context-hash": "{{.*}}",
+// CHECK_MODULE-NEXT:           "module-name": "FW"
+// CHECK_MODULE-NEXT:         },
+// CHECK_MODULE-NEXT:         {
+// CHECK_MODULE-NEXT:           "context-hash": "{{.*}}",
+// CHECK_MODULE-NEXT:           "module-name": "FW_Private"
+// CHECK_MODULE-NEXT:         }
+// CHECK_MODULE-NEXT:       ],
+// CHECK_MODULE-NEXT:       "clang-modulemap-file": "[[PREFIX]]/module.modulemap",
+// CHECK_MODULE-NEXT:       "command-line": [
+// CHECK_MODULE:              "-fmodule-file={{.*}}/FW-{{.*}}.pcm"
+// CHECK_MODULE:              "-fmodule-file={{.*}}/FW_Private-{{.*}}.pcm"
+// CHECK_MODULE:            ],
+// CHECK_MODULE-NEXT:       "context-hash": "{{.*}}",
+// CHECK_MODULE-NEXT:       "file-deps": [
+// CHECK_MODULE-NEXT:         "[[PREFIX]]/Mod.h"
+// CHECK_MODULE-NEXT:         "[[PREFIX]]/frameworks/FW.framework/Modules/module.modulemap",
+// CHECK_MODULE-NEXT:         "[[PREFIX]]/frameworks/FW.framework/Modules/module.private.modulemap",
+// CHECK_MODULE-NEXT:         "[[PREFIX]]/frameworks/FW.framework/PrivateHeaders/Two.h",
+// CHECK_MODULE-NEXT:         "[[PREFIX]]/module.modulemap"
+// CHECK_MODULE-NEXT:       ],
+// CHECK_MODULE-NEXT:       "name": "Mod"
+// CHECK_MODULE-NEXT:     }
+// CHECK_MODULE-NEXT:   ],
+// CHECK_MODULE-NEXT:   "translation-units": [
+// CHECK_MODULE-NEXT:     {
+// CHECK_MODULE-NEXT:       "clang-context-hash": "{{.*}}",
+// CHECK_MODULE-NEXT:       "clang-module-deps": [
+// CHECK_MODULE-NEXT:         {
+// CHECK_MODULE-NEXT:           "context-hash": "{{.*}}",
+// CHECK_MODULE-NEXT:           "module-name": "Mod"
+// CHECK_MODULE-NEXT:         }
+// CHECK_MODULE-NEXT:       ],
+// CHECK_MODULE-NEXT:       "command-line": [
+// CHECK_MODULE:            ],
+// CHECK_MODULE-NEXT:       "file-deps": [
+// CHECK_MODULE-NEXT:         "[[PREFIX]]/from_module.m"
+// CHECK_MODULE-NEXT:       ],
+// CHECK_MODULE-NEXT:       "input-file": "[[PREFIX]]/from_module.m"
+// CHECK_MODULE-NEXT:     }
+// CHECK_MODULE-NEXT:   ]
+// CHECK_MODULE-NEXT: }
+
+// RUN: %deps-to-rsp %t/from_module_result.json --module-name=FW > %t/FW.cc1.rsp
+// RUN: %deps-to-rsp %t/from_module_result.json --module-name=FW_Private > %t/FW_Private.cc1.rsp
+// RUN: %deps-to-rsp %t/from_module_result.json --module-name=Mod > %t/Mod.cc1.rsp
+// RUN: %deps-to-rsp %t/from_module_result.json --tu-index=0 > %t/tu.rsp
+// RUN: %clang @%t/FW.cc1.rsp
+// RUN: %clang @%t/FW_Private.cc1.rsp
+// RUN: %clang @%t/Mod.cc1.rsp
+// RUN: %clang @%t/tu.rsp