WIP: AST{Reader,Writer} alternative

[jansvoboda11]

Prevent module redefinition errors, fix memory leak

[dblaikie]

("Simple" tends to be an over used/overly vague term and may become less correct over time - if there's some more descriptive term that explains the difference between the old and newer one it'd be awesome to use - but yeah, sometimes "Simple", "New", etc, is just the way it goes :))

[jansvoboda11]

Using CompilerInstance as the module storage dramatically increases memory usage (peak ~30GB) of clang-scan-deps when scanning LLVM. (Memory mapping serialized files peaks at ~300MB.)

clang/include/clang/Basic/SourceLocation.h

public:
   bool operator>=(const FileID &RHS) const { return RHS <= *this; }
 
   static FileID getSentinel() { return get(-1); }
   unsigned getHashValue() const { return static_cast<unsigned>(ID); }
 
 private:
   friend class ASTWriter;
   friend class ASTReader;
+  friend class SimpleASTWriter;
+  friend class SimpleASTReader;
   friend class SourceManager;
 
   static FileID get(int V) {
     FileID F;
     F.ID = V;
     return F;
   }
 

 ///
 /// In addition, one bit of SourceLocation is used for quick access to the
 /// information whether the location is in a file or a macro expansion.
 ///
 /// It is important that this type remains small. It is currently 32 bits wide.
 class SourceLocation {
   friend class ASTReader;
   friend class ASTWriter;
+  friend class SimpleASTReader;
   friend class SourceManager;
   friend struct llvm::FoldingSetTrait<SourceLocation, void>;
 
 public:
   using UIntTy = uint32_t;
   using IntTy = int32_t;
 
 private:

clang/include/clang/Basic/SourceManager.h

public:
   }
 
   /// \return Location of the top-level macro caller.
   SourceLocation getTopMacroCallerLoc(SourceLocation Loc) const;
 
 private:
   friend class ASTReader;
   friend class ASTWriter;
+  friend class SimpleASTReader;
+  friend class SimpleASTWriter;
 
   llvm::MemoryBufferRef getFakeBufferForRecovery() const;
   SrcMgr::ContentCache &getFakeContentCacheForRecovery() const;
 
   const SrcMgr::SLocEntry &loadSLocEntry(unsigned Index, bool *Invalid) const;
 
   const SrcMgr::SLocEntry *getSLocEntryOrNull(FileID FID) const {
     bool Invalid = false;

clang/include/clang/Frontend/CompilerInstance.h

 class raw_fd_ostream;
 class Timer;
 class TimerGroup;
 }
 
 namespace clang {
 class ASTContext;
 class ASTReader;
+class SimpleASTReader;
+class SimpleASTWriter;
+class SimpleModuleCache;
 class CodeCompleteConsumer;
 class DiagnosticsEngine;
 class DiagnosticConsumer;
 class FileManager;
 class FrontendAction;
 class InMemoryModuleCache;
 class Module;
 class Preprocessor;
class CompilerInstance : public ModuleLoader {
   std::unique_ptr<llvm::TimerGroup> FrontendTimerGroup;
 
   /// The frontend timer.
   std::unique_ptr<llvm::Timer> FrontendTimer;
 
   /// The ASTReader, if one exists.
   IntrusiveRefCntPtr<ASTReader> TheASTReader;
 
+  /// The simple ASTReader, if one exists.
+  std::shared_ptr<SimpleASTReader> TheSimpleASTReader;
+  /// The simple ASTWriter, if one exists.
+  std::shared_ptr<SimpleASTWriter> TheSimpleASTWriter;
+  /// The simple module cache, if one exists.
+  SimpleModuleCache *TheSimpleModuleCache;
+
   /// The module dependency collector for crashdumps
   std::shared_ptr<ModuleDependencyCollector> ModuleDepCollector;
 
   /// The module provider.
   std::shared_ptr<PCHContainerOperations> ThePCHContainerOperations;
 
   std::vector<std::shared_ptr<DependencyCollector>> DependencyCollectors;
 
public:
 
   /// }
   /// @name Module Management
   /// {
 
   IntrusiveRefCntPtr<ASTReader> getASTReader() const;
   void setASTReader(IntrusiveRefCntPtr<ASTReader> Reader);
 
+  std::shared_ptr<SimpleASTReader> getSimpleASTReader() const;
+  std::shared_ptr<SimpleASTWriter> getSimpleASTWriter() const;
+
+  SimpleModuleCache *getSimpleModuleCache();
+  void setSimpleModuleCache(SimpleModuleCache *Cache);
+
   std::shared_ptr<ModuleDependencyCollector> getModuleDepCollector() const;
   void setModuleDepCollector(
       std::shared_ptr<ModuleDependencyCollector> Collector);
 
   std::shared_ptr<PCHContainerOperations> getPCHContainerOperations() const {
     return ThePCHContainerOperations;
   }
 
void setOutputStream(std::unique_ptr<llvm::raw_pwrite_stream> OutStream) {
     OutputStream = std::move(OutStream);
   }
 
   std::unique_ptr<llvm::raw_pwrite_stream> takeOutputStream() {
     return std::move(OutputStream);
   }
 
   void createASTReader();
+  void createSimpleASTReader();
+  void createSimpleASTWriter();
 
   bool loadModuleFile(StringRef FileName);
 
 private:
   /// Find a module, potentially compiling it, before reading its AST.  This is
   /// the guts of loadModule.
   ///
   /// For prebuilt modules, the Module is not expected to exist in

clang/include/clang/Lex/ModuleMap.h

private:
   llvm::DenseMap<const DirectoryEntry *, InferredDirectory> InferredDirectories;
 
   /// A mapping from an inferred module to the module map that allowed the
   /// inference.
   llvm::DenseMap<const Module *, const FileEntry *> InferredModuleAllowedBy;
 
   llvm::DenseMap<const Module *, AdditionalModMapsSet> AdditionalModMaps;
 
+  friend class SimpleASTReader;
   /// Describes whether we haved parsed a particular file as a module
   /// map.
   llvm::DenseMap<const FileEntry *, bool> ParsedModuleMap;
 
   /// Resolve the given export declaration into an actual export
   /// declaration.
   ///
   /// \param Mod The module in which we're resolving the export declaration.

clang/include/clang/Lex/Preprocessor.h

 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Registry.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <map>
 #include <memory>
+#include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
 template<unsigned InternalLen> class SmallString;
 
public:
 
   /// Return the submodule owning the file being lexed. This may not be
   /// the current module if we have changed modules since entering the file.
   Module *getCurrentLexerSubmodule() const { return CurLexerSubmodule; }
 
   /// Returns the FileID for the preprocessor predefines.
   FileID getPredefinesFileID() const { return PredefinesFileID; }
 
+  std::set<const FileEntry *> getAffectingModuleMaps(Module *M);
+
   /// \{
   /// Accessors for preprocessor callbacks.
   ///
   /// Note that this class takes ownership of any PPCallbacks object given to
   /// it.
   PPCallbacks *getPPCallbacks() const { return Callbacks.get(); }
   void addPPCallbacks(std::unique_ptr<PPCallbacks> C) {
     if (Callbacks)

clang/include/clang/Lex/PreprocessorOptions.h

 /// PreprocessorOptions - This class is used for passing the various options
 /// used in preprocessor initialization to InitializePreprocessor().
 class PreprocessorOptions {
 public:
   std::vector<std::pair<std::string, bool/*isUndef*/>> Macros;
   std::vector<std::string> Includes;
   std::vector<std::string> MacroIncludes;
 
+  bool ScanningMode = false;
+
   /// Initialize the preprocessor with the compiler and target specific
   /// predefines.
   bool UsePredefines = true;
 
   /// Whether we should maintain a detailed record of all macro
   /// definitions and expansions.
   bool DetailedRecord = false;
 

clang/include/clang/Lex/Token.h

bool getFlag(TokenFlags Flag) const {
     return (Flags & Flag) != 0;
   }
 
   /// Unset the specified flag.
   void clearFlag(TokenFlags Flag) {
     Flags &= ~Flag;
   }
 
-  /// Return the internal represtation of the flags.
+  /// Return the internal representation of the flags.
   ///
   /// This is only intended for low-level operations such as writing tokens to
   /// disk.
   unsigned getFlags() const {
     return Flags;
   }
 
+  /// Set the internal representation of the flags.
+  ///
+  /// This is only intended for low-level operations such as writing tokens to
+  /// disk.
+  void setFlags(unsigned Flags) {
+    this->Flags = Flags;
+  }
+
   /// Set a flag to either true or false.
   void setFlagValue(TokenFlags Flag, bool Val) {
     if (Val)
       setFlag(Flag);
     else
       clearFlag(Flag);
   }
 

clang/include/clang/Serialization/Simple/ASTReader.h

+#ifndef LLVM_CLANG_SERIALIZATION_SIMPLE_ASTREADER_H
+#define LLVM_CLANG_SERIALIZATION_SIMPLE_ASTREADER_H
+
+#include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Lex/ExternalPreprocessorSource.h"
+#include "clang/Lex/HeaderSearch.h"
+#include "clang/Lex/PreprocessingRecord.h"
+#include "clang/Sema/ExternalSemaSource.h"
+#include "clang/Serialization/Simple/ModuleCache.h"
+#include "clang/Serialization/Simple/ModuleFile.h"
+#include "clang/Serialization/Simple/ModuleManager.h"
+
+namespace clang {
+/// The evil twin of ASTReader.
+class SimpleASTReader : public ExternalPreprocessorSource,
+                        public ExternalPreprocessingRecordSource,
+                        public ExternalHeaderFileInfoSource,
+                        public ExternalSemaSource,
+                        public IdentifierInfoLookup,
+                        public ExternalSLocEntrySource {
+  using SimpleModuleManager = serialization::SimpleModuleManager;
+  using SimpleModuleFile = serialization::SimpleModuleFile;
+
+  SimpleModuleCache *Cache;
+
+  SimpleModuleManager ModuleMgr;
+
+public:
+  // Custom {
+  explicit SimpleASTReader(SimpleModuleCache *Cache)
+      : Cache(std::move(Cache)) {}
+
+  SimpleModuleManager &getModuleManager() { return ModuleMgr; }
+
+  SimpleModuleCache &getCache() { return *Cache; }
+
+  bool readAST(StringRef ModuleName, CompilerInstance &CI);
+
+  void readASTCore(StringRef Name, SimpleModuleFile *ImportedBy,
+                   llvm::SmallVectorImpl<SimpleModuleFile *> &Loaded);
+  void readASTBlock(SimpleModuleFile &F, CompilerInstance &CI);
+
+  using InputFileVisitorTy = llvm::function_ref<void(
+      const serialization::SimpleInputFile &IF, bool isSystem)>;
+  using TopLevelModuleMapVisitorTy =
+      llvm::function_ref<void(const FileEntry *)>;
+
+  void visitInputFiles(SimpleModuleFile &MF, bool IncludeSystem, bool Complain,
+                       InputFileVisitorTy Visitor);
+
+  void visitTopLevelModuleMaps(SimpleModuleFile &MF,
+                               TopLevelModuleMapVisitorTy Visitor);
+
+  // Custom }
+
+  // clang-format off
+
+  // ExternalPreprocessorSource {
+  void ReadDefinedMacros() override {}
+  void updateOutOfDateIdentifier(IdentifierInfo &II) override {}
+  IdentifierInfo *GetIdentifier(unsigned int ID) override { return {}; }
+  Module *getModule(unsigned int ModuleID) override { return {}; }
+  // ExternalPreprocessorSource }
+
+  // ExternalPreprocessingRecordSource {
+  PreprocessedEntity *ReadPreprocessedEntity(unsigned int Index) override { return {}; }
+  std::pair<unsigned int, unsigned int> findPreprocessedEntitiesInRange(SourceRange Range) override { return {}; }
+  Optional<bool> isPreprocessedEntityInFileID(unsigned Index, FileID FID) override { return {}; }
+  SourceRange ReadSkippedRange(unsigned int Index) override { return {}; }
+  // ExternalPreprocessingRecordSource }
+
+  // ExternalHeaderFileInfoSource {
+  HeaderFileInfo GetHeaderFileInfo(const FileEntry *FE) override { return {}; }
+  // ExternalHeaderFileInfoSource }
+
+  // ExternalSemaSource {
+  // ExternalSemaSource }
+
+  // IdentifierInfoLookup {
+  IdentifierInfo *get(StringRef Name) override { return {}; }
+  IdentifierIterator *getIdentifiers() override { return {}; }
+  // IdentifierInfoLookup }
+
+  // ExternalSLocEntrySource {
+  bool ReadSLocEntry(int ID) override { return false; }
+  std::pair<SourceLocation, StringRef> getModuleImportLoc(int ID) override { return {}; }
+  // ExternalSLocEntrySource }
+
+  // clang-format on
+
+  class ASTTransfer {
+    CompilerInstance &A;
+    Preprocessor &APP;
+    SourceManager &ASM;
+    FileManager &AFM;
+    HeaderSearch &AHS;
+
+    CompilerInstance &B;
+    Preprocessor &BPP;
+    SourceManager &BSM;
+    FileManager &BFM;
+    HeaderSearch &BHS;
+
+    const Module *BModule;
+    const SimpleModuleFile *AModuleFile;
+
+    llvm::StringSet<> TranslatedModules;
+
+  public:
+    ASTTransfer(CompilerInstance &A, CompilerInstance &B,
+                StringRef BModuleName);
+
+    void translateFileManager();
+    const FileEntry &translate(const FileEntry &BFE);
+    FileEntryRef translate(FileEntryRef BFE);
+    const DirectoryEntry &translate(const DirectoryEntry &BDE);
+
+    void translateSourceManager();
+    SourceLocation translate(SourceLocation Loc) const;
+    SourceLocation::UIntTy translate(SourceLocation::UIntTy Offset,
+                                     const SimpleModuleFile *MF = nullptr);
+    Optional<SrcMgr::FileInfo> translate(const SrcMgr::FileInfo &BFI);
+    SrcMgr::ContentCache *translate(const SrcMgr::ContentCache &BCC);
+    int translateSLocEntryID(int EntryID, const SimpleModuleFile *MF = nullptr);
+
+    void translatePreprocessor();
+    void translateModule();
+    Module &translate(Module &BMod);
+    const Module &translate(const Module &BMod);
+    Module::Header translate(const Module::Header &BHeader);
+    std::vector<Module *> translate(Module::submodule_iterator Begin,
+                                    Module::submodule_iterator End);
+    Module::UnresolvedHeaderDirective
+    translate(const Module::UnresolvedHeaderDirective &BD);
+    Module::ExportDecl translate(const Module::ExportDecl &BED);
+    ModuleId translate(const ModuleId &BId);
+    Module::UnresolvedExportDecl
+    translate(const Module::UnresolvedExportDecl &BUED);
+    Module::LinkLibrary translate(const Module::LinkLibrary &X);
+    Module::UnresolvedConflict translate(const Module::UnresolvedConflict &X);
+    Module::Conflict translate(const Module::Conflict &X);
+    IdentifierInfo &translate(IdentifierInfo &BII);
+    Token translate(const Token &BTok);
+    MacroInfo &translate(MacroInfo &BMI);
+
+    template <class T> Optional<T> translate(const Optional<T> &BO) {
+      if (!BO)
+        return None;
+      return translate(*BO);
+    }
+
+    template <class T> const T *translate(const T *BP) {
+      if (!BP)
+        return nullptr;
+      return &translate(*BP);
+    }
+
+    template <class T> T *translate(T *BP) {
+      if (!BP)
+        return nullptr;
+      return &translate(*BP);
+    }
+
+    template <class T, class U>
+    llvm::PointerUnion<T, U> translate(llvm::PointerUnion<T, U> BPU) {
+      if (!BPU)
+        return nullptr;
+      if (BPU.template is<T>())
+        return translate(BPU.template get<T>());
+      return translate(BPU.template get<U>());
+    }
+
+    template <class T, unsigned N>
+    SmallVector<T, N> translate(const SmallVector<T, N> &BV) {
+      SmallVector<T, N> AV;
+      AV.reserve(BV.size());
+      for (const T &Entry : BV)
+        AV.push_back(translate(Entry));
+      return AV;
+    }
+
+    template <class T, unsigned N>
+    llvm::SmallSetVector<T, N>
+    translate(const llvm::SmallSetVector<T, N> &BSSV) {
+      llvm::SmallSetVector<T, N> ASSV;
+      for (const auto &Entry : BSSV)
+        ASSV.insert(translate(Entry));
+      return ASSV;
+    }
+  };
+};
+} // namespace clang
+
+#endif // LLVM_CLANG_SERIALIZATION_SIMPLE_ASTREADER_H

clang/include/clang/Serialization/Simple/ASTWriter.h

+#ifndef LLVM_CLANG_SERIALIZATION_SIMPLE_ASTWRITER_H
+#define LLVM_CLANG_SERIALIZATION_SIMPLE_ASTWRITER_H
+
+#include "clang/Serialization/Simple/ModuleCache.h"
+
+namespace clang {
+/// The evil twin of ASTReader.
+class SimpleASTWriter {
+  using SimpleModuleManager = serialization::SimpleModuleManager;
+  using SimpleModuleFile = serialization::SimpleModuleFile;
+
+  SimpleModuleCache *Cache;
+
+  SimpleASTReader *ASTRdr;
+
+public:
+  explicit SimpleASTWriter(SimpleModuleCache *Cache, SimpleASTReader *ASTRdr)
+      : Cache(std::move(Cache)), ASTRdr(ASTRdr) {}
+
+  void writeAST(StringRef ModuleName, Module *WritingModule,
+                std::shared_ptr<CompilerInstance> CI) {
+    SimplePCM &PCM =
+        Cache->insert(ModuleName, SimplePCM(std::move(CI), WritingModule));
+
+    assert(ASTRdr);
+    SimpleModuleManager &ModuleMgr = ASTRdr->getModuleManager();
+    for (const std::unique_ptr<SimpleModuleFile> &M : ModuleMgr)
+      PCM.SLocEntryBaseOffsets.emplace_back(M->ModuleName,
+                                            M->SLocEntryBaseOffset);
+    //
+  }
+};
+} // namespace clang
+
+#endif // LLVM_CLANG_SERIALIZATION_SIMPLE_ASTWRITER_H

clang/include/clang/Serialization/Simple/ModuleCache.h

+#ifndef LLVM_CLANG_SERIALIZATION_SIMPLE_MODULECACHE_H
+#define LLVM_CLANG_SERIALIZATION_SIMPLE_MODULECACHE_H
+
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "llvm/ADT/StringMap.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace clang {
+struct SimplePCM {
+  std::shared_ptr<CompilerInstance> CI;
+
+  Module *CompiledModule;
+
+  std::vector<std::pair<std::string, SourceLocation::UIntTy>>
+      SLocEntryBaseOffsets;
+
+  SimplePCM(std::shared_ptr<CompilerInstance> CI, Module *CompiledModule)
+      : CI(std::move(CI)), CompiledModule(CompiledModule) {}
+
+  unsigned localValidSLocEntryCount() const {
+    // Subtracting 1 to ignore to invalid entry at index 0.
+    return CI->getSourceManager().local_sloc_entry_size() - 1;
+  }
+
+  SourceLocation::UIntTy getLastLocalOffset() const {
+    // Subtracting 1 to get the last local offset.
+    return CI->getSourceManager().getNextLocalOffset() - 1;
+  }
+};
+
+class SimpleModuleCache {
+  llvm::StringMap<SimplePCM> PCMs;
+
+public:
+  SimplePCM &insert(StringRef Name, SimplePCM PCM) {
+    return PCMs.insert({Name, std::move(PCM)}).first->getValue();
+  }
+
+  SimplePCM *lookup(StringRef Name) {
+    auto It = PCMs.find(Name);
+    if (It == PCMs.end())
+      return nullptr;
+    return &It->second;
+  }
+};
+} // namespace clang
+
+#endif // LLVM_CLANG_SERIALIZATION_SIMPLE_MODULECACHE_H

clang/include/clang/Serialization/Simple/ModuleFile.h

+#ifndef LLVM_CLANG_SERIALIZATION_SIMPLE_MODULEFILE_H
+#define LLVM_CLANG_SERIALIZATION_SIMPLE_MODULEFILE_H
+
+#include "clang/Basic/FileEntry.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Serialization/ContinuousRangeMap.h"
+#include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/SetVector.h"
+
+namespace clang {
+namespace serialization {
+/// The input file that has been loaded from this AST file, along with
+/// bools indicating whether this was an overridden buffer or if it was
+/// out-of-date or not-found.
+class SimpleInputFile {
+  enum { Overridden = 1, OutOfDate = 2, NotFound = 3 };
+  llvm::PointerIntPair<const FileEntryRef::MapEntry *, 2, unsigned> Val;
+
+public:
+  SimpleInputFile() = default;
+
+  SimpleInputFile(FileEntryRef File, bool isOverridden = false,
+                  bool isOutOfDate = false) {
+    assert(!(isOverridden && isOutOfDate) &&
+           "an overridden cannot be out-of-date");
+    unsigned intVal = 0;
+    if (isOverridden)
+      intVal = Overridden;
+    else if (isOutOfDate)
+      intVal = OutOfDate;
+    Val.setPointerAndInt(&File.getMapEntry(), intVal);
+  }
+
+  static SimpleInputFile getNotFound() {
+    SimpleInputFile File;
+    File.Val.setInt(NotFound);
+    return File;
+  }
+
+  OptionalFileEntryRefDegradesToFileEntryPtr getFile() const {
+    if (auto *P = Val.getPointer())
+      return FileEntryRef(*P);
+    return None;
+  }
+  bool isOverridden() const { return Val.getInt() == Overridden; }
+  bool isOutOfDate() const { return Val.getInt() == OutOfDate; }
+  bool isNotFound() const { return Val.getInt() == NotFound; }
+};
+
+struct SimpleModuleFile {
+  std::string ModuleName;
+
+  llvm::SetVector<SimpleModuleFile *> Imports;
+
+  /// The base ID in the source manager's view of this module.
+  int SLocEntryBaseID = 0;
+
+  /// The base offset in the source manager's view of this module.
+  SourceLocation::UIntTy SLocEntryBaseOffset = 0;
+
+  /// Remapping table for source locations in this module.
+  ContinuousRangeMap<SourceLocation::UIntTy, SourceLocation::IntTy, 2>
+      SLocRemap;
+
+  // TODO: Pull this on-demand from SimpleInMemoryPCM?
+  llvm::BitVector SearchPathUsage;
+
+  SimpleModuleFile(StringRef Name) : ModuleName(Name.str()) {}
+};
+} // namespace serialization
+} // namespace clang
+
+#endif // LLVM_CLANG_SERIALIZATION_SIMPLE_MODULEFILE_H

clang/include/clang/Serialization/Simple/ModuleManager.h

+#ifndef LLVM_CLANG_SERIALIZATION_SIMPLE_MODULEMANAGER_H
+#define LLVM_CLANG_SERIALIZATION_SIMPLE_MODULEMANAGER_H
+
+#include "clang/Serialization/Simple/ModuleFile.h"
+
+#include "llvm/ADT/SmallVector.h"
+
+#include <memory>
+
+namespace clang {
+namespace serialization {
+class SimpleModuleManager {
+  /// The chain of modules, in the order in which we started to load
+  /// them (this order isn't really useful for anything).
+  SmallVector<std::unique_ptr<SimpleModuleFile>, 2> Chain;
+
+  /// All loaded modules, indexed by name.
+  llvm::StringMap<SimpleModuleFile *> Modules;
+
+public:
+  SimpleModuleFile *lookup(StringRef Name) const {
+    return Modules.lookup(Name);
+  }
+
+  /// The result of attempting to add a new module.
+  enum AddModuleResult {
+    AlreadyLoaded,
+    NewlyLoaded,
+  };
+
+  AddModuleResult addModule(StringRef Name, SimpleModuleFile *ImportedBy,
+                            SimpleModuleFile *&Module) {
+    auto UpdateModuleImports = [&](SimpleModuleFile &MF,
+                                   SimpleModuleFile *ImportedBy) {
+      if (ImportedBy)
+        ImportedBy->Imports.insert(&MF);
+    };
+
+    if (SimpleModuleFile *ModuleEntry = Modules.lookup(Name)) {
+      Module = ModuleEntry;
+      UpdateModuleImports(*ModuleEntry, ImportedBy);
+      return AlreadyLoaded;
+    }
+
+    Chain.push_back(std::make_unique<SimpleModuleFile>(Name));
+    Module = Modules[Name] = Chain.back().get();
+    UpdateModuleImports(*Module, ImportedBy);
+    return NewlyLoaded;
+  }
+
+  auto begin() { return Chain.begin(); }
+  auto end() { return Chain.end(); }
+};
+} // namespace serialization
+} // namespace clang
+
+#endif // LLVM_CLANG_SERIALIZATION_SIMPLE_MODULEMANAGER_H

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

struct ModuleDeps {
   bool IsSystem;
 
   /// The path to the modulemap file which defines this module.
   ///
   /// This can be used to explicitly build this module. This file will
   /// additionally appear in \c FileDeps as a dependency.
   std::string ClangModuleMapFile;
 
-  /// The path to where an implicit build would put the PCM for this module.
-  std::string ImplicitModulePCMPath;
-
   /// A collection of absolute paths to files that this module directly depends
   /// on, not including transitive dependencies.
   llvm::StringSet<> FileDeps;
 
   /// A collection of absolute paths to module map files that this module needs
   /// to know about. The ordering is significant.
   std::vector<std::string> ModuleMapFileDeps;
 

clang/lib/Frontend/CompilerInstance.cpp

 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Serialization/ASTReader.h"
 #include "clang/Serialization/GlobalModuleIndex.h"
 #include "clang/Serialization/InMemoryModuleCache.h"
+#include "clang/Serialization/Simple/ASTReader.h"
+#include "clang/Serialization/Simple/ASTWriter.h"
+#include "clang/Serialization/Simple/ModuleCache.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/BuryPointer.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
IntrusiveRefCntPtr<ASTReader> CompilerInstance::getASTReader() const {
   return TheASTReader;
 }
 void CompilerInstance::setASTReader(IntrusiveRefCntPtr<ASTReader> Reader) {
   assert(ModuleCache.get() == &Reader->getModuleManager().getModuleCache() &&
          "Expected ASTReader to use the same PCM cache");
   TheASTReader = std::move(Reader);
 }
 
+std::shared_ptr<SimpleASTReader> CompilerInstance::getSimpleASTReader() const {
+  return TheSimpleASTReader;
+}
+
+std::shared_ptr<SimpleASTWriter> CompilerInstance::getSimpleASTWriter() const {
+  return TheSimpleASTWriter;
+}
+
+SimpleModuleCache *CompilerInstance::getSimpleModuleCache() {
+  return TheSimpleModuleCache;
+}
+
+void CompilerInstance::setSimpleModuleCache(SimpleModuleCache *Cache) {
+  TheSimpleModuleCache = Cache;
+}
+
 std::shared_ptr<ModuleDependencyCollector>
 CompilerInstance::getModuleDepCollector() const {
   return ModuleDepCollector;
 }
 
 void CompilerInstance::setModuleDepCollector(
     std::shared_ptr<ModuleDependencyCollector> Collector) {
   ModuleDepCollector = std::move(Collector);
compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
   assert(ImportingInstance.getInvocation().getModuleHash() ==
          Invocation->getModuleHash() && "Module hash mismatch!");
 
   // Construct a compiler instance that will be used to actually create the
   // module.  Since we're sharing an in-memory module cache,
   // CompilerInstance::CompilerInstance is responsible for finalizing the
   // buffers to prevent use-after-frees.
-  CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
-                            &ImportingInstance.getModuleCache());
+  auto InstancePtr = std::make_shared<CompilerInstance>(
+      ImportingInstance.getPCHContainerOperations(),
+  CompilerInstance& Instance = *InstancePtr;
   auto &Inv = *Invocation;
   Instance.setInvocation(std::move(Invocation));
 
   Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
                                    ImportingInstance.getDiagnosticClient()),
                              /*ShouldOwnClient=*/true);
 
   if (FrontendOpts.ModulesShareFileManager) {
     Instance.setFileManager(&ImportingInstance.getFileManager());
   } else {
     Instance.createFileManager(&ImportingInstance.getVirtualFileSystem());
   }
   Instance.createSourceManager(Instance.getFileManager());
   SourceManager &SourceMgr = Instance.getSourceManager();
 
+  Instance.setSimpleModuleCache(ImportingInstance.getSimpleModuleCache());
+
   // Note that this module is part of the module build stack, so that we
   // can detect cycles in the module graph.
   SourceMgr.setModuleBuildStack(
     ImportingInstance.getSourceManager().getModuleBuildStack());
   SourceMgr.pushModuleBuildStack(ModuleName,
     FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
 
   // If we're collecting module dependencies, we need to share a collector
   // between all of the module CompilerInstances. Other than that, we don't
   // want to produce any dependency output from the module build.
   Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
   Inv.getDependencyOutputOpts() = DependencyOutputOptions();
 
   ImportingInstance.getDiagnostics().Report(ImportLoc,
                                             diag::remark_module_build)
     << ModuleName << ModuleFileName;
 
   PreBuildStep(Instance);
 
+  if (Instance.getPreprocessorOpts().ScanningMode) {
+    llvm::errs() << "{{{{{{{{{{ " << ModuleName << "\n";
+  }
+
   // Execute the action to actually build the module in-place. Use a separate
   // thread so that we get a stack large enough.
   bool Crashed = !llvm::CrashRecoveryContext().RunSafelyOnThread(
       [&]() {
         GenerateModuleFromModuleMapAction Action;
         Instance.ExecuteAction(Action);
       },
       DesiredStackSize);
 
+  if (Instance.getPreprocessorOpts().ScanningMode) {
+    if (!Instance.getSimpleASTReader())
+      Instance.createSimpleASTReader();
+    if (!Instance.getSimpleASTWriter())
+      Instance.createSimpleASTWriter();
+
+    assert(Instance.getLangOpts().isCompilingModule());
+    Module *Module =
+        Instance.getPreprocessor().getHeaderSearchInfo().lookupModule(
+            Instance.getLangOpts().CurrentModule, SourceLocation(),
+            /*AllowSearch=*/false);
+    assert(Module);
+
+    Instance.getSimpleASTWriter()->writeAST(ModuleName, Module, InstancePtr);
+    llvm::errs() << "}}}}}}}}}} " << ModuleName << "\n";
+    ImportingInstance.getSimpleASTReader()->readAST(ModuleName, ImportingInstance);
+  }
+
   PostBuildStep(Instance);
 
   ImportingInstance.getDiagnostics().Report(ImportLoc,
                                             diag::remark_module_build_done)
     << ModuleName;
 
   if (Crashed) {
     // Clear the ASTConsumer if it hasn't been already, in case it owns streams

 }
 
 /// Read the AST right after compiling the module.
 static bool readASTAfterCompileModule(CompilerInstance &ImportingInstance,
                                       SourceLocation ImportLoc,
                                       SourceLocation ModuleNameLoc,
                                       Module *Module, StringRef ModuleFileName,
                                       bool *OutOfDate) {
+  // Do not attempt to read the AST file.
+  if (ImportingInstance.getPreprocessorOpts().ScanningMode)
+    return true;
+
   DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
 
   unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
   if (OutOfDate)
     ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
 
   // Try to read the module file, now that we've compiled it.
   ASTReader::ASTReadResult ReadResult =
for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
     // If we removed all of the files in the directory, remove the directory
     // itself.
     if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
             llvm::sys::fs::directory_iterator() && !EC)
       llvm::sys::fs::remove(Dir->path());
   }
 }
 
+void CompilerInstance::createSimpleASTReader() {
+  if (TheSimpleASTReader)
+    return;
+
+  TheSimpleASTReader = std::make_shared<SimpleASTReader>(TheSimpleModuleCache);
+}
+
+void CompilerInstance::createSimpleASTWriter() {
+  if (TheSimpleASTWriter)
+    return;
+
+  TheSimpleASTWriter = std::make_shared<SimpleASTWriter>(
+      TheSimpleModuleCache, TheSimpleASTReader.get());
+}
+
 void CompilerInstance::createASTReader() {
   if (TheASTReader)
     return;
 
   if (!hasASTContext())
     createASTContext();
 
   // If we're implicitly building modules but not currently recursively

 ModuleLoadResult CompilerInstance::findOrCompileModuleAndReadAST(
     StringRef ModuleName, SourceLocation ImportLoc,
     SourceLocation ModuleNameLoc, bool IsInclusionDirective) {
   // Search for a module with the given name.
   HeaderSearch &HS = PP->getHeaderSearchInfo();
   Module *M =
       HS.lookupModule(ModuleName, ImportLoc, true, !IsInclusionDirective);
 
+  if (getPreprocessorOpts().ScanningMode) {
+    // Create an ASTTransfer on demand.
+    if (!getSimpleASTReader())
+      createSimpleASTReader();
+    if (getSimpleASTReader()->readAST(ModuleName, *this))
+      return M;
+  }
+
   // Select the source and filename for loading the named module.
   std::string ModuleFilename;
   ModuleSource Source =
       selectModuleSource(M, ModuleName, ModuleFilename, BuiltModules, HS);
   if (Source == MS_ModuleNotFound) {
     // We can't find a module, error out here.
     getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
         << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
for (unsigned I = 1, N = Path.size(); I != N; ++I) {
     }
 
     Module = Sub;
   }
 
   // Make the named module visible, if it's not already part of the module
   // we are parsing.
   if (ModuleName != getLangOpts().CurrentModule) {
-    if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
+    if (!getPreprocessorOpts().ScanningMode && !Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
       // We have an umbrella header or directory that doesn't actually include
       // all of the headers within the directory it covers. Complain about
       // 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()

clang/lib/Frontend/FrontendAction.cpp

if (DisableFree) {
       CI.setPreprocessor(nullptr);
       CI.setSourceManager(nullptr);
       CI.setFileManager(nullptr);
     }
   }
 
   setCompilerInstance(nullptr);
   setCurrentInput(FrontendInputFile());
-  CI.getLangOpts().setCompilingModule(LangOptions::CMK_None);
+//  CI.getLangOpts().setCompilingModule(LangOptions::CMK_None);
 }
 
 bool FrontendAction::shouldEraseOutputFiles() {
   return getCompilerInstance().getDiagnostics().hasErrorOccurred();
 }
 
 //===----------------------------------------------------------------------===//
 // Utility Actions

clang/lib/Frontend/FrontendActions.cpp

 
 std::unique_ptr<ASTConsumer>
 ASTViewAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   return CreateASTViewer();
 }
 
 std::unique_ptr<ASTConsumer>
 GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
+  if (CI.getPreprocessorOpts().ScanningMode)
+    return std::make_unique<ASTConsumer>();
+
   std::string Sysroot;
   if (!ComputeASTConsumerArguments(CI, /*ref*/ Sysroot))
     return nullptr;
 
   std::string OutputFile;
   std::unique_ptr<raw_pwrite_stream> OS =
       CreateOutputFile(CI, InFile, /*ref*/ OutputFile);
   if (!OS)

 bool GeneratePCHAction::BeginSourceFileAction(CompilerInstance &CI) {
   CI.getLangOpts().CompilingPCH = true;
   return true;
 }
 
 std::unique_ptr<ASTConsumer>
 GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI,
                                         StringRef InFile) {
+  if (CI.getPreprocessorOpts().ScanningMode)
+    return std::make_unique<ASTConsumer>();
+
   std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
   if (!OS)
     return nullptr;
 
   std::string OutputFile = CI.getFrontendOpts().OutputFile;
   std::string Sysroot;
 
   auto Buffer = std::make_shared<PCHBuffer>();

clang/lib/Lex/Preprocessor.cpp

 
 Module *Preprocessor::getCurrentModuleImplementation() {
   if (!getLangOpts().isCompilingModuleImplementation())
     return nullptr;
 
   return getHeaderSearchInfo().lookupModule(getLangOpts().ModuleName);
 }
 
+std::set<const FileEntry *> Preprocessor::getAffectingModuleMaps(Module *M) {
+  Module *RootModule = M;
+  const HeaderSearch &HS = HeaderInfo;
+
+  std::set<const FileEntry *> ModuleMaps{};
+  std::set<const Module *> ProcessedModules;
+  SmallVector<const Module *> ModulesToProcess{RootModule};
+
+  SmallVector<const FileEntry *, 16> FilesByUID;
+  HS.getFileMgr().GetUniqueIDMapping(FilesByUID);
+
+  if (FilesByUID.size() > HS.header_file_size())
+    FilesByUID.resize(HS.header_file_size());
+
+  for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
+    const FileEntry *File = FilesByUID[UID];
+    if (!File)
+      continue;
+
+    const HeaderFileInfo *HFI =
+        HS.getExistingFileInfo(File, /*WantExternal*/ false);
+    if (!HFI || (HFI->isModuleHeader && !HFI->isCompilingModuleHeader))
+      continue;
+
+    for (const auto &KH : HS.findAllModulesForHeader(File)) {
+      if (!KH.getModule())
+        continue;
+      ModulesToProcess.push_back(KH.getModule());
+    }
+  }
+
+  while (!ModulesToProcess.empty()) {
+    auto *CurrentModule = ModulesToProcess.pop_back_val();
+    ProcessedModules.insert(CurrentModule);
+
+    Optional<FileEntryRef> ModuleMapFile =
+        HS.getModuleMap().getModuleMapFileForUniquing(CurrentModule);
+    if (!ModuleMapFile) {
+      continue;
+    }
+
+    ModuleMaps.insert(*ModuleMapFile);
+
+    for (auto *ImportedModule : (CurrentModule)->Imports) {
+      if (!ImportedModule ||
+          ProcessedModules.find(ImportedModule) != ProcessedModules.end()) {
+        continue;
+      }
+      ModulesToProcess.push_back(ImportedModule);
+    }
+
+    for (const Module *UndeclaredModule : CurrentModule->UndeclaredUses)
+      if (UndeclaredModule &&
+          ProcessedModules.find(UndeclaredModule) == ProcessedModules.end())
+        ModulesToProcess.push_back(UndeclaredModule);
+  }
+
+  return ModuleMaps;
+}
+
 //===----------------------------------------------------------------------===//
 // Preprocessor Initialization Methods
 //===----------------------------------------------------------------------===//
 
 /// EnterMainSourceFile - Enter the specified FileID as the main source file,
 /// which implicitly adds the builtin defines etc.
 void Preprocessor::EnterMainSourceFile() {
   // We do not allow the preprocessor to reenter the main file.  Doing so will

clang/lib/Serialization/ASTWriter.cpp

#include "clang/Serialization/TypeBitCodes.def"
   case Type::Builtin:
     llvm_unreachable("shouldn't be serializing a builtin type this way");
   }
   llvm_unreachable("bad type kind");
 }
 
 namespace {
 
-std::set<const FileEntry *> GetAffectingModuleMaps(const HeaderSearch &HS,
-                                                   Module *RootModule) {
-  std::set<const FileEntry *> ModuleMaps{};
-  std::set<const Module *> ProcessedModules;
-  SmallVector<const Module *> ModulesToProcess{RootModule};
-
-  SmallVector<const FileEntry *, 16> FilesByUID;
-  HS.getFileMgr().GetUniqueIDMapping(FilesByUID);
-
-  if (FilesByUID.size() > HS.header_file_size())
-    FilesByUID.resize(HS.header_file_size());
-
-  for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
-    const FileEntry *File = FilesByUID[UID];
-    if (!File)
-      continue;
-
-    const HeaderFileInfo *HFI =
-        HS.getExistingFileInfo(File, /*WantExternal*/ false);
-    if (!HFI || (HFI->isModuleHeader && !HFI->isCompilingModuleHeader))
-      continue;
-
-    for (const auto &KH : HS.findAllModulesForHeader(File)) {
-      if (!KH.getModule())
-        continue;
-      ModulesToProcess.push_back(KH.getModule());
-    }
-  }
-
-  while (!ModulesToProcess.empty()) {
-    auto *CurrentModule = ModulesToProcess.pop_back_val();
-    ProcessedModules.insert(CurrentModule);
-
-    Optional<FileEntryRef> ModuleMapFile =
-        HS.getModuleMap().getModuleMapFileForUniquing(CurrentModule);
-    if (!ModuleMapFile) {
-      continue;
-    }
-
-    ModuleMaps.insert(*ModuleMapFile);
-
-    for (auto *ImportedModule : (CurrentModule)->Imports) {
-      if (!ImportedModule ||
-          ProcessedModules.find(ImportedModule) != ProcessedModules.end()) {
-        continue;
-      }
-      ModulesToProcess.push_back(ImportedModule);
-    }
-
-    for (const Module *UndeclaredModule : CurrentModule->UndeclaredUses)
-      if (UndeclaredModule &&
-          ProcessedModules.find(UndeclaredModule) == ProcessedModules.end())
-        ModulesToProcess.push_back(UndeclaredModule);
-  }
-
-  return ModuleMaps;
-}
-
 class ASTTypeWriter {
   ASTWriter &Writer;
   ASTWriter::RecordData Record;
   ASTRecordWriter BasicWriter;
 
 public:
   ASTTypeWriter(ASTWriter &Writer)
     : Writer(Writer), BasicWriter(Writer, Record) {}
void ASTWriter::collectNonAffectingInputFiles() {
   SourceManager &SrcMgr = PP->getSourceManager();
   unsigned N = SrcMgr.local_sloc_entry_size();
 
   IsSLocAffecting.resize(N, true);
 
   if (!WritingModule)
     return;
 
-  auto AffectingModuleMaps =
-      GetAffectingModuleMaps(PP->getHeaderSearchInfo(), WritingModule);
+  auto AffectingModuleMaps = PP->getAffectingModuleMaps(WritingModule);
 
   unsigned FileIDAdjustment = 0;
   unsigned OffsetAdjustment = 0;
 
   NonAffectingFileIDAdjustments.reserve(N);
   NonAffectingOffsetAdjustments.reserve(N);
 
   NonAffectingFileIDAdjustments.push_back(FileIDAdjustment);

clang/lib/Serialization/CMakeLists.txt

add_clang_library(clangSerialization
   GeneratePCH.cpp
   GlobalModuleIndex.cpp
   InMemoryModuleCache.cpp
   ModuleFile.cpp
   ModuleFileExtension.cpp
   ModuleManager.cpp
   PCHContainerOperations.cpp
 
+  Simple/ASTReader.cpp
+
   ADDITIONAL_HEADERS
   ASTCommon.h
   ASTReaderInternals.h
 
   LINK_LIBS
   clangAST
   clangBasic
   clangLex
   clangSema
 
   DEPENDS
   omp_gen
   )

clang/lib/Serialization/GeneratePCH.cpp

 //===--- GeneratePCH.cpp - Sema Consumer for PCH Generation -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the PCHGenerator, which as a SemaConsumer that generates
 //  a PCH file.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTContext.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
+#include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Sema/SemaConsumer.h"
 #include "clang/Serialization/ASTWriter.h"
 #include "llvm/Bitstream/BitstreamWriter.h"
 
 using namespace clang;
 
 PCHGenerator::PCHGenerator(
     const Preprocessor &PP, InMemoryModuleCache &ModuleCache,
: PP(PP), OutputFile(OutputFile), isysroot(isysroot.str()),
       ShouldCacheASTInMemory(ShouldCacheASTInMemory) {
   this->Buffer->IsComplete = false;
 }
 
 PCHGenerator::~PCHGenerator() {
 }
 
 void PCHGenerator::HandleTranslationUnit(ASTContext &Ctx) {
+  // Do not attempt to write the AST file.
+  if (PP.getPreprocessorOpts().ScanningMode)
+    return;
+
   // Don't create a PCH if there were fatal failures during module loading.
   if (PP.getModuleLoader().HadFatalFailure)
     return;
 
   bool hasErrors = PP.getDiagnostics().hasErrorOccurred();
   if (hasErrors && !AllowASTWithErrors)
     return;
 

clang/lib/Serialization/Simple/ASTReader.cpp

+#include "clang/Serialization/Simple/ASTReader.h"
+
+#include "clang/Lex/Preprocessor.h"
+
+using namespace clang;
+
+/*
+namespace serialization2 {
+  SourceLocation translate(SourceLocation BLoc) {
+    if (BLoc.isInvalid())
+      return {};
+
+auto BOffset = BSM.getFileOffset(BLoc);
+auto AOffset = BOffset;
+
+auto BFileID = BSM.getFileID(BLoc);
+auto AFileID = [&]() {
+  if (BFileID == BPP.getPredefinesFileID())
+    return APP.getPredefinesFileID();
+
+  auto *BSLocEntry = BSM.getSLocEntryForFile(BFileID);
+
+  if (BSLocEntry->isFile()) {
+    if (auto BBuffer =
+            BSLocEntry->getFile().getContentCache().getBufferIfLoaded()) {
+      auto ABuffer = llvm::MemoryBuffer::getMemBuffer(*BBuffer);
+
+      auto BFileCharacteristic = BSM.getFileCharacteristic(BLoc);
+      auto AFileCharacteristic = BFileCharacteristic;
+
+      // TODO: Implement this.
+      int LoadedID = 0;
+      SourceLocation::UIntTy LoadedOffset = 0;
+
+      return ASM.createFileID(std::move(ABuffer), AFileCharacteristic,
+                              LoadedID, LoadedOffset);
+    }
+  }
+
+  auto *BFileEntry = BSM.getFileEntryForID(BFileID);
+  auto *AFileEntry = translate(BFileEntry);
+
+  auto BIncludeLoc = BSM.getIncludeLoc(BFileID);
+  auto AIncludeLoc = translate(BIncludeLoc);
+
+  auto BFileCharacteristic = BSM.getFileCharacteristic(BLoc);
+  auto AFileCharacteristic = BFileCharacteristic;
+
+  // TODO: Implement this.
+  int LoadedID = 0;
+  SourceLocation::UIntTy LoadedOffset = 0;
+
+  return ASM.createFileID(AFileEntry, AIncludeLoc, AFileCharacteristic,
+                          LoadedID, LoadedOffset);
+}();
+
+return ASM.getComposedLoc(AFileID, AOffset);
+}
+};
+
+// TODO: Integrate this properly.
+void foo() {
+  for (const auto &X : Instance.SortedFiles)
+    if (!ImportingInstance.SortedFiles.count(X.getKey()))
+      ImportingInstance.SortedFiles[X.getKey()] = X.getValue();
+
+  auto &SortedFiles = ImportingInstance.SortedFiles[ModuleName];
+
+  std::set<const FileEntry *> AffectingModuleMaps = GetAffectingModuleMaps(
+      Instance.getPreprocessor().getHeaderSearchInfo(),
+      Instance.getPreprocessor().getHeaderSearchInfo().lookupModule(
+          ModuleName));
+
+  SourceManager &SrcMgr = Instance.getPreprocessor().getSourceManager();
+  unsigned N = SrcMgr.local_sloc_entry_size();
+
+  for (unsigned I = 1; I != N; ++I) {
+    const SrcMgr::SLocEntry *SLoc = &SrcMgr.getLocalSLocEntry(I);
+
+    if (!SLoc->isFile())
+      continue;
+    const SrcMgr::FileInfo &File = SLoc->getFile();
+    const SrcMgr::ContentCache *Cache = &File.getContentCache();
+    if (!Cache->OrigEntry)
+      continue;
+
+    if (!isModuleMap(File.getFileCharacteristic()) ||
+        AffectingModuleMaps.empty() ||
+        AffectingModuleMaps.find(Cache->OrigEntry) !=
+            AffectingModuleMaps.end()) {
+      CompilerInstance::EntryStruct Entry{
+          T.translate(Cache->OrigEntry),
+          isSystem(File.getFileCharacteristic()),
+          isModuleMap(File.getFileCharacteristic()) &&
+              File.getIncludeLoc().isInvalid()};
+
+      if (Entry.IsSystemFile)
+        SortedFiles.push_back(Entry);
+      else
+        SortedFiles.push_front(Entry);
+    }
+  }
+}
+} // namespace
+} // namespace serialization2
+*/
+
+/// Mapping from a source location entry to whether it is affecting or not.
+/// Mostly copied from ASTWriter.cpp.
+llvm::BitVector collectNonAffectingInputFiles(Preprocessor &PP, Module *M) {
+  SourceManager &SrcMgr = PP.getSourceManager();
+  unsigned BN = SrcMgr.local_sloc_entry_size();
+
+  llvm::BitVector IsSLocAffecting(BN, true);
+
+  auto AffectingModuleMaps = PP.getAffectingModuleMaps(M);
+
+  for (unsigned I = 1; I != BN; ++I) {
+    const SrcMgr::SLocEntry *SLoc = &SrcMgr.getLocalSLocEntry(I);
+
+    if (!SLoc->isFile())
+      continue;
+    const SrcMgr::FileInfo &File = SLoc->getFile();
+    const SrcMgr::ContentCache *Cache = &File.getContentCache();
+    if (!Cache->OrigEntry)
+      continue;
+
+    if (!isModuleMap(File.getFileCharacteristic()) ||
+        AffectingModuleMaps.empty() ||
+        AffectingModuleMaps.find(Cache->OrigEntry) != AffectingModuleMaps.end())
+      continue;
+
+    IsSLocAffecting[I] = false;
+  }
+
+  return IsSLocAffecting;
+}
+
+bool SimpleASTReader::readAST(StringRef ModuleName, CompilerInstance &CI) {
+  SimplePCM *PCM = Cache->lookup(ModuleName);
+  if (PCM == nullptr)
+    return false;
+
+  llvm::SmallVector<SimpleModuleFile *> LoadedMFs;
+  readASTCore(ModuleName, nullptr, LoadedMFs);
+  for (SimpleModuleFile *LoadedMF : LoadedMFs)
+    readASTBlock(*LoadedMF, CI);
+
+  ASTTransfer T(CI, *PCM->CI, ModuleName);
+  T.translateFileManager();
+  T.translateSourceManager();
+  T.translatePreprocessor();
+  T.translateModule();
+
+  return true;
+}
+
+void SimpleASTReader::readASTCore(
+    StringRef Name, SimpleModuleFile *ImportedBy,
+    llvm::SmallVectorImpl<SimpleModuleFile *> &Loaded) {
+  SimpleModuleFile *M;
+  SimpleModuleManager::AddModuleResult AddResult =
+      ModuleMgr.addModule(Name, ImportedBy, M);
+
+  switch (AddResult) {
+  case SimpleModuleManager::AlreadyLoaded:
+    return;
+  case SimpleModuleManager::NewlyLoaded:
+    break;
+  }
+
+  // ReadControlBlock
+  SimplePCM *PCM = Cache->lookup(Name);
+  if (auto OtherReader = PCM->CI->getSimpleASTReader())
+    for (auto &X : OtherReader->getModuleManager())
+      readASTCore(X->ModuleName, M, Loaded);
+
+  std::vector<bool> SearchPathUsage =
+      PCM->CI->getPreprocessor().getHeaderSearchInfo().computeUserEntryUsage();
+  M->SearchPathUsage.resize(SearchPathUsage.size());
+  for (unsigned I = 0; I < SearchPathUsage.size(); ++I)
+    M->SearchPathUsage[I] = SearchPathUsage[I];
+
+  Loaded.push_back(M);
+}
+
+void SimpleASTReader::readASTBlock(SimpleModuleFile &F, CompilerInstance &CI) {
+  SimplePCM *PCM = Cache->lookup(F.ModuleName);
+  assert(PCM);
+
+  std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
+      CI.getSourceManager().AllocateLoadedSLocEntries(
+          PCM->localValidSLocEntryCount(), PCM->getLastLocalOffset());
+
+  // These would be needed if we implemented the lazy-loading API
+  // (ExternalSLocEntrySource).
+#if 0
+  // Make our entry in the range map. BaseID is negative and growing, so
+  // we invert it. Because we invert it, though, we need the other end of
+  // the range.
+  unsigned RangeStart =
+      unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
+  GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
+  F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
+
+  // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
+  assert((F.SLocEntryBaseOffset & SourceLocation::MacroIDBit) == 0);
+  ImportsInfo.DepRemaps[ModuleName].GlobalSLocOffsetMap.insert(std::make_pair(
+      SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset - SLocSpaceSize,
+      &F));
+#endif
+
+  // Initialize the remapping table.
+  // Invalid stays invalid.
+  F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
+  // This module. Base was 2 when being compiled.
+  F.SLocRemap.insertOrReplace(std::make_pair(
+      2U, static_cast<SourceLocation::IntTy>(F.SLocEntryBaseOffset - 2)));
+
+  for (const auto &[Name, SLocOffset] : PCM->SLocEntryBaseOffsets) {
+    SimpleModuleFile *OM = ModuleMgr.lookup(Name);
+
+    // Continuous range maps we may be updating in our module.
+    using SLocRemapBuilder =
+        ContinuousRangeMap<SourceLocation::UIntTy, SourceLocation::IntTy,
+                           2>::Builder;
+    SLocRemapBuilder SLocRemap(F.SLocRemap);
+    SLocRemap.insert({SLocOffset, static_cast<SourceLocation::IntTy>(
+                                      OM->SLocEntryBaseOffset - SLocOffset)});
+  }
+}
+
+void SimpleASTReader::visitInputFiles(SimpleModuleFile &MF, bool IncludeSystem,
+                                      bool Complain,
+                                      InputFileVisitorTy Visitor) {
+  SimplePCM *PCM = Cache->lookup(MF.ModuleName);
+  assert(PCM);
+  SourceManager &SourceMgr = PCM->CI->getSourceManager();
+  unsigned N = PCM->CI->getSourceManager().local_sloc_entry_size();
+  for (unsigned I = 1; I != N; ++I) {
+    SrcMgr::SLocEntry &SLoc = SourceMgr.LocalSLocEntryTable[I];
+    if (!SLoc.isFile())
+      continue;
+    const SrcMgr::FileInfo &FI = SLoc.getFile();
+    if (auto MaybeEntry = FI.getContentCache().OrigEntry)
+      Visitor(*MaybeEntry, false);
+  }
+}
+
+void SimpleASTReader::visitTopLevelModuleMaps(
+    SimpleModuleFile &MF, TopLevelModuleMapVisitorTy Visitor) {
+  SimplePCM *PCM = Cache->lookup(MF.ModuleName);
+  assert(PCM);
+
+  Preprocessor &PP = PCM->CI->getPreprocessor();
+  SourceManager &SourceMgr = PP.getSourceManager();
+
+  llvm::BitVector IsInputFileAffecting =
+      collectNonAffectingInputFiles(PP, PCM->CompiledModule);
+
+  unsigned N = SourceMgr.local_sloc_entry_size();
+  for (unsigned I = 1; I != N; ++I) {
+    SrcMgr::SLocEntry &SLoc = SourceMgr.LocalSLocEntryTable[I];
+    if (!SLoc.isFile())
+      continue;
+    const SrcMgr::FileInfo &FI = SLoc.getFile();
+    if (IsInputFileAffecting[I] &&
+        SrcMgr::isModuleMap(FI.getFileCharacteristic()))
+      if (auto MaybeEntry = FI.getContentCache().OrigEntry)
+        Visitor(*MaybeEntry);
+  }
+}
+
+SimpleASTReader::ASTTransfer::ASTTransfer(CompilerInstance &A,
+                                          CompilerInstance &B,
+                                          StringRef BModuleName)
+    : A(A), APP(A.getPreprocessor()), ASM(A.getSourceManager()),
+      AFM(A.getFileManager()), AHS(A.getPreprocessor().getHeaderSearchInfo()),
+      B(B), BPP(B.getPreprocessor()), BSM(B.getSourceManager()),
+      BFM(B.getFileManager()), BHS(B.getPreprocessor().getHeaderSearchInfo()),
+      BModule(BHS.getModuleMap().findModule(BModuleName)),
+      AModuleFile(
+          A.getSimpleASTReader()->getModuleManager().lookup(BModuleName)) {}
+
+void SimpleASTReader::ASTTransfer::translateFileManager() {
+  //
+}
+
+void SimpleASTReader::ASTTransfer::translateSourceManager() {
+  // We can't translate SLocEntries eagerly. Creating a FileID
+
+  for (const auto &MF : A.getSimpleASTReader()->getModuleManager()) {
+    SimplePCM *PCM = A.getSimpleASTReader()->getCache().lookup(MF->ModuleName);
+    assert(PCM);
+
+    SourceManager &SourceMgr = PCM->CI->getSourceManager();
+    unsigned N = SourceMgr.local_sloc_entry_size();
+    for (unsigned I = 1; I != N; ++I) {
+      SrcMgr::SLocEntry &SLoc = SourceMgr.LocalSLocEntryTable[I];
+
+      int AFileID = translateSLocEntryID(I, MF.get());
+      SourceLocation::UIntTy AOffset = translate(SLoc.getOffset(), MF.get());
+      unsigned Index = -AFileID - 2;
+
+      if (SLoc.isFile()) {
+        const SrcMgr::FileInfo &File = SLoc.getFile();
+        const SrcMgr::ContentCache *Content = &File.getContentCache();
+
+        if (Content->OrigEntry) {
+          if (!ASM.SLocEntryLoaded[Index])
+            ASM.createFileID(translate(*Content->OrigEntry),
+                             translate(File.getIncludeLoc()),
+                             File.getFileCharacteristic(), AFileID, AOffset);
+        } else {
+          llvm::Optional<llvm::MemoryBufferRef> Buffer =
+              Content->getBufferOrNone(PCM->CI->getDiagnostics(),
+                                       PCM->CI->getFileManager());
+          assert(Buffer);
+          if (!ASM.SLocEntryLoaded[Index])
+            ASM.createFileID(*Buffer, File.getFileCharacteristic(), AFileID,
+                             AOffset);
+        }
+      } else {
+        const SrcMgr::ExpansionInfo &Expansion = SLoc.getExpansion();
+
+        if (!ASM.SLocEntryLoaded[Index]) {
+          SourceLocation::UIntTy NextOffset = SourceMgr.getNextLocalOffset();
+          if (I + 1 != N)
+            NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset();
+          unsigned Length = NextOffset - SLoc.getOffset() - 1;
+
+          ASM.createExpansionLoc(translate(Expansion.getSpellingLoc()),
+                                 translate(Expansion.getExpansionLocStart()),
+                                 translate(Expansion.getExpansionLocEnd()),
+                                 Length, Expansion.isExpansionTokenRange(),
+                                 AFileID, AOffset);
+        }
+      }
+      /*
+      // We will detect whether a file changed and return 'Failure' for it, but
+      // we will also try to fail gracefully by setting up the SLocEntry.
+      unsigned InputID = Record[4];
+      InputFile IF = getInputFile(*F, InputID);
+      Optional<FileEntryRef> File = IF.getFile();
+      bool OverriddenBuffer = IF.isOverridden();
+
+      SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
+      if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
+        // This is the module's main file.
+        IncludeLoc = getImportLocation(F);
+      }
+      SrcMgr::CharacteristicKind
+          FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
+      FileID FID = SourceMgr.createFileID(*File, IncludeLoc, FileCharacter, ID,
+                                          BaseOffset + Record[0]);
+      SrcMgr::FileInfo &FileInfo =
+          const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
+      FileInfo.NumCreatedFIDs = Record[5];
+      if (Record[3])
+        FileInfo.setHasLineDirectives();
+
+      unsigned NumFileDecls = Record[7];
+      if (NumFileDecls && ContextObj) {
+        const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
+        assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
+        FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
+                                                               NumFileDecls));
+      }
+
+      const SrcMgr::ContentCache &ContentCache =
+          SourceMgr.getOrCreateContentCache(*File, isSystem(FileCharacter));
+      if (OverriddenBuffer && !ContentCache.BufferOverridden &&
+          ContentCache.ContentsEntry == ContentCache.OrigEntry &&
+          !ContentCache.getBufferIfLoaded()) {
+        auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
+        if (!Buffer)
+          return true;
+        SourceMgr.overrideFileContents(*File, std::move(Buffer));
+      }
+
+      break;
+    }
+    case SM_SLOC_BUFFER_ENTRY: {
+      const char *Name = Blob.data();
+      unsigned Offset = Record[0];
+      SrcMgr::CharacteristicKind
+          FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
+      SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
+      if (IncludeLoc.isInvalid() && F->isModule()) {
+        IncludeLoc = getImportLocation(F);
+      }
+
+      auto Buffer = ReadBuffer(SLocEntryCursor, Name);
+      if (!Buffer)
+        return true;
+      SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
+                             BaseOffset + Offset, IncludeLoc);
+      break;
+    }
+    */
+    }
+  }
+}
+
+SourceLocation
+SimpleASTReader::ASTTransfer::translate(SourceLocation Loc) const {
+  assert(AModuleFile->SLocRemap.find(Loc.getOffset()) !=
+             AModuleFile->SLocRemap.end() &&
+         "Cannot find offset to remap.");
+  SourceLocation::IntTy Remap =
+      AModuleFile->SLocRemap.find(Loc.getOffset())->second;
+  return Loc.getLocWithOffset(Remap);
+}
+
+SourceLocation::UIntTy
+SimpleASTReader::ASTTransfer::translate(SourceLocation::UIntTy Offset,
+                                        const SimpleModuleFile *MF) {
+  if (!MF)
+    MF = AModuleFile;
+  return Offset + MF->SLocRemap.find(Offset)->second;
+}
+
+SrcMgr::ContentCache *
+SimpleASTReader::ASTTransfer::translate(const SrcMgr::ContentCache &BCC) {
+  if (auto AOrigEntry = translate(BCC.OrigEntry))
+    return &ASM.getOrCreateContentCache(*AOrigEntry,
+                                        /*isSystemFile=*/false);
+  return nullptr;
+}
+
+Optional<SrcMgr::FileInfo>
+SimpleASTReader::ASTTransfer::translate(const SrcMgr::FileInfo &BFI) {
+  if (auto *AContentCache = translate(BFI.getContentCache()))
+    return SrcMgr::FileInfo::get(translate(BFI.getIncludeLoc()), *AContentCache,
+                                 BFI.getFileCharacteristic(), BFI.getName());
+  return None;
+}
+
+int SimpleASTReader::ASTTransfer::translateSLocEntryID(
+    int EntryID, const SimpleModuleFile *MF) {
+  if (!MF)
+    MF = AModuleFile;
+  return MF->SLocEntryBaseID + EntryID - 1;
+}
+
+const FileEntry &SimpleASTReader::ASTTransfer::translate(const FileEntry &BFE) {
+  if (auto MaybeAFE = AFM.getFile(BFE.getName()))
+    return **MaybeAFE;
+  return *AFM.getVirtualFile(BFE.getName(), BFE.getSize(),
+                             BFE.getModificationTime());
+}
+
+FileEntryRef SimpleASTReader::ASTTransfer::translate(FileEntryRef BFE) {
+  if (auto AFE = AFM.getOptionalFileRef(BFE.getNameAsRequested()))
+    return *AFE;
+  return AFM.getVirtualFileRef(BFE.getNameAsRequested(), BFE.getSize(),
+                               BFE.getModificationTime());
+}
+
+const DirectoryEntry &
+SimpleASTReader::ASTTransfer::translate(const DirectoryEntry &BDE) {
+  return **AFM.getDirectory(BDE.getName());
+}
+
+Module::Header
+SimpleASTReader::ASTTransfer::translate(const Module::Header &BHeader) {
+  return Module::Header{BHeader.NameAsWritten,
+                        BHeader.PathRelativeToRootModuleDirectory,
+                        translate(BHeader.Entry)};
+}
+
+std::vector<Module *>
+SimpleASTReader::ASTTransfer::translate(Module::submodule_iterator Begin,
+                                        Module::submodule_iterator End) {
+  std::vector<Module *> ASubModules;
+  for (auto It = Begin; It != End; ++It)
+    ASubModules.push_back(translate(*It));
+  return ASubModules;
+}
+
+Module::UnresolvedHeaderDirective SimpleASTReader::ASTTransfer::translate(
+    const Module::UnresolvedHeaderDirective &BD) {
+  return {BD.Kind, //
+          translate(BD.FileNameLoc),
+          BD.FileName,
+          BD.IsUmbrella,
+          BD.HasBuiltinHeader,
+          BD.Size,
+          BD.ModTime};
+}
+
+Module::ExportDecl
+SimpleASTReader::ASTTransfer::translate(const Module::ExportDecl &BED) {
+  return {translate(BED.getPointer()), BED.getInt()};
+}
+
+ModuleId SimpleASTReader::ASTTransfer::translate(const ModuleId &BId) {
+  ModuleId Res;
+  for (const auto &Element : BId)
+    Res.push_back({Element.first, translate(Element.second)});
+  return Res;
+}
+
+Module::UnresolvedExportDecl SimpleASTReader::ASTTransfer::translate(
+    const Module::UnresolvedExportDecl &BUED) {
+  return {translate(BUED.ExportLoc), translate(BUED.Id), BUED.Wildcard};
+}
+
+Module::LinkLibrary
+SimpleASTReader::ASTTransfer::translate(const Module::LinkLibrary &X) {
+  return X;
+}
+
+Module::UnresolvedConflict
+SimpleASTReader::ASTTransfer::translate(const Module::UnresolvedConflict &X) {
+  return {translate(X.Id), X.Message};
+}
+
+Module::Conflict
+SimpleASTReader::ASTTransfer::translate(const Module::Conflict &X) {
+  return {translate(X.Other), X.Message};
+}
+
+const Module &SimpleASTReader::ASTTransfer::translate(const Module &BMod) {
+  return translate(const_cast<Module &>(BMod));
+}
+
+Module &SimpleASTReader::ASTTransfer::translate(Module &BMod) {
+  auto &AModMap = AHS.getModuleMap();
+
+  auto [AMod, New] = AModMap.findOrCreateModule(
+      BMod.Name, translate(BMod.Parent), BMod.IsFramework, BMod.IsExplicit);
+
+  if (!TranslatedModules.insert({BMod.Name}).second)
+    return *AMod;
+
+  AMod->Kind = BMod.Kind;
+  AMod->Directory = translate(BMod.Directory);
+  AMod->PresumedModuleMapFile = BMod.PresumedModuleMapFile;
+
+  // This is being dropped by PCM files and propagating it causes module
+  // redefinitions. HACK: Making sure we don't parse this module map ever again.
+  // TODO: Fix this properly.
+  AMod->DefinitionLoc = translate(BMod.DefinitionLoc);
+  AModMap.ParsedModuleMap[ASM.getFileEntryForID(
+      ASM.getFileID(AMod->DefinitionLoc))] = true;
+
+  AMod->Umbrella = translate(BMod.Umbrella);
+  AMod->UmbrellaAsWritten = BMod.UmbrellaAsWritten;
+  AMod->UmbrellaRelativeToRootModuleDirectory =
+      BMod.UmbrellaRelativeToRootModuleDirectory;
+  AMod->ExportAsModule = BMod.ExportAsModule;
+
+  for (Module *BSubMod : BMod.submodules())
+    translate(BSubMod);
+
+  for (const FileEntry *BTopHeader : BMod.getTopHeaders(B.getFileManager()))
+    AMod->addTopHeader(translate(BTopHeader));
+
+  // TODO: Propagate VisibilityID to other data structures.
+
+  for (auto Kind : {Module::HK_Normal, Module::HK_Textual, Module::HK_Private,
+                    Module::HK_PrivateTextual, Module::HK_Excluded}) {
+    for (const auto &BH : BMod.Headers[Kind]) {
+      const auto &AH = translate(BH);
+      AModMap.addHeader(AMod, AH, ModuleMap::headerKindToRole(Kind),
+                        BHS.getFileInfo(BH.Entry).isModuleHeader);
+    }
+  }
+
+  AMod->UnresolvedHeaders = translate(BMod.UnresolvedHeaders);
+  AMod->MissingHeaders = translate(BMod.MissingHeaders);
+  AMod->Requirements = BMod.Requirements;
+  AMod->ShadowingModule = translate(BMod.ShadowingModule);
+  AMod->IsUnimportable = BMod.IsUnimportable;
+  AMod->HasIncompatibleModuleFile = BMod.HasIncompatibleModuleFile;
+  AMod->IsAvailable = BMod.IsAvailable;
+  AMod->IsFromModuleFile = BMod.IsFromModuleFile;
+  AMod->IsFramework = BMod.IsFramework;
+  AMod->IsExplicit = BMod.IsExplicit;
+  AMod->IsSystem = BMod.IsSystem;
+  AMod->IsExternC = BMod.IsExternC;
+  // This is being dropped by PCM files and propagating it triggers
+  // asserts.
+  // AMod->IsInferred = BMod.IsInferred;
+  AMod->InferSubmodules = BMod.InferSubmodules;
+  AMod->InferExplicitSubmodules = BMod.InferExplicitSubmodules;
+  AMod->InferExportWildcard = BMod.InferExportWildcard;
+  AMod->ConfigMacrosExhaustive = BMod.ConfigMacrosExhaustive;
+  AMod->NoUndeclaredIncludes = BMod.NoUndeclaredIncludes;
+  AMod->ModuleMapIsPrivate = BMod.ModuleMapIsPrivate;
+  AMod->NameVisibility = BMod.NameVisibility;
+  AMod->InferredSubmoduleLoc = translate(BMod.InferredSubmoduleLoc);
+  AMod->Imports = translate(BMod.Imports);
+  AMod->Exports = translate(BMod.Exports);
+  AMod->UnresolvedExports = translate(BMod.UnresolvedExports);
+  AMod->DirectUses = translate(BMod.DirectUses);
+  AMod->UnresolvedDirectUses = translate(BMod.UnresolvedDirectUses);
+  AMod->UndeclaredUses = translate(BMod.UndeclaredUses);
+  AMod->LinkLibraries = translate(BMod.LinkLibraries);
+  AMod->UseExportAsModuleLinkName = BMod.UseExportAsModuleLinkName;
+  AMod->ConfigMacros = BMod.ConfigMacros;
+  AMod->UnresolvedConflicts = BMod.UnresolvedConflicts;
+  AMod->Conflicts = BMod.Conflicts;
+
+  return *AMod;
+}
+
+void SimpleASTReader::ASTTransfer::translateModule() { translate(BModule); }
+
+IdentifierInfo &SimpleASTReader::ASTTransfer::translate(IdentifierInfo &BII) {
+  auto &AII = APP.getIdentifierTable().getOwn(BII.getName());
+
+  AII.setOutOfDate(false);
+
+  // TODO: Check if is interesting.
+
+  if (BII.hasRevertedTokenIDToIdentifier() &&
+      BII.getTokenID() != tok::TokenKind::identifier)
+    AII.revertTokenIDToIdentifier();
+  AII.setObjCOrBuiltinID(BII.getObjCOrBuiltinID());
+  AII.setIsPoisoned(BII.isPoisoned());
+
+  AII.setObjCKeywordID(BII.getObjCKeywordID());
+  AII.setHasMacroDefinition(BII.hasMacroDefinition());
+
+  return AII;
+}
+
+Token SimpleASTReader::ASTTransfer::translate(const Token &BTok) {
+  Token ATok;
+  ATok.startToken();
+  ATok.setLocation(translate(BTok.getLocation()));
+  ATok.setLength(BTok.getLength());
+  ATok.setIdentifierInfo(translate(BTok.getIdentifierInfo()));
+  ATok.setKind(BTok.getKind());
+  ATok.setFlags(BTok.getFlags());
+  return ATok;
+}
+
+MacroInfo &SimpleASTReader::ASTTransfer::translate(MacroInfo &BMI) {
+  auto BLoc = BMI.getDefinitionLoc();
+  auto ALoc = translate(BLoc);
+
+  MacroInfo &AMI = *APP.AllocateMacroInfo(ALoc);
+  AMI.setDefinitionEndLoc(BMI.getDefinitionEndLoc());
+  AMI.setIsUsed(BMI.isUsed());
+  AMI.setUsedForHeaderGuard(BMI.isUsedForHeaderGuard());
+
+  if (BMI.isFunctionLike()) {
+    AMI.setIsFunctionLike();
+    if (BMI.isC99Varargs())
+      AMI.setIsC99Varargs();
+    if (BMI.isGNUVarargs())
+      AMI.setIsGNUVarargs();
+    if (BMI.hasCommaPasting())
+      AMI.setHasCommaPasting();
+    std::vector<IdentifierInfo *> AParams;
+    for (const IdentifierInfo *BParam : BMI.params())
+      AParams.push_back(translate(const_cast<IdentifierInfo *>(BParam)));
+    AMI.setParameterList(AParams, APP.getPreprocessorAllocator());
+  }
+
+  // TODO: Complete preprocessing record.
+
+  std::vector<Token> AToks;
+  for (const Token &BTok : BMI.tokens())
+    AToks.push_back(translate(BTok));
+  AMI.setTokens(AToks, APP.getPreprocessorAllocator());
+
+  return AMI;
+}
+
+void SimpleASTReader::ASTTransfer::translatePreprocessor() {
+  for (const auto &BEntry : BPP.getIdentifierTable()) {
+    IdentifierInfo *BII = BEntry.getValue();
+
+    if (!BII->hadMacroDefinition())
+      continue;
+
+    // Macro directive history is not read for modules.
+
+    IdentifierInfo *BName = BII;
+    IdentifierInfo *AName = translate(BII);
+
+    // TODO: Why does this keep happening to me?
+    //    BName->setOutOfDate(false);
+
+    auto BLeafs = BPP.getLeafModuleMacros(BName);
+    SmallVector<ModuleMacro *, 8> BMacros(BLeafs.begin(), BLeafs.end());
+    llvm::DenseMap<ModuleMacro *, unsigned> Visits;
+    for (unsigned I = 0; I < BMacros.size(); ++I)
+      // Enqueue overridden macros once we've visited all their ancestors.
+      for (auto *BModuleMacro : BMacros[I]->overrides())
+        if (++Visits[BModuleMacro] == BModuleMacro->getNumOverridingMacros())
+          BMacros.push_back(BModuleMacro);
+
+    // Module macros are listed in reverse dependency order.
+    for (const auto *BMacro : llvm::reverse(BMacros)) {
+      auto *AModule = translate(BMacro->getOwningModule());
+      auto *AMacroInfo = translate(BMacro->getMacroInfo());
+
+      std::vector<ModuleMacro *> AOverrides;
+      for (auto *BOverride : BMacro->overrides()) {
+        auto *AOverrideModule = translate(BOverride->getOwningModule());
+        auto *AOverride = APP.getModuleMacro(AOverrideModule, AName);
+        assert(AOverride && "missing definition for overridden macro");
+        AOverrides.push_back(AOverride);
+      }
+
+      bool Inserted = false;
+      APP.addModuleMacro(AModule, AName, AMacroInfo, AOverrides, Inserted);
+    }
+  }
+}

clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp

 #include "clang/Driver/Job.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/Lex/PreprocessorOptions.h"
+#include "clang/Serialization/Simple/ASTReader.h"
+#include "clang/Serialization/Simple/ASTWriter.h"
+#include "clang/Serialization/Simple/ModuleCache.h"
 #include "clang/Tooling/DependencyScanning/DependencyScanningService.h"
 #include "clang/Tooling/DependencyScanning/ModuleDepCollector.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Host.h"
 
 using namespace clang;
 using namespace tooling;
 using namespace dependencies;
bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation,
 
     Scanned = true;
 
     // Create a compiler instance to handle the actual work.
     ScanInstanceStorage.emplace(std::move(PCHContainerOps));
     CompilerInstance &ScanInstance = *ScanInstanceStorage;
     ScanInstance.setInvocation(std::move(Invocation));
 
+    ScanInstance.getFrontendOpts().BuildingImplicitModuleUsesLock = false;
+    ScanInstance.getPreprocessorOpts().ScanningMode = true;
+
     // Create the compiler's actual diagnostics engine.
     sanitizeDiagOpts(ScanInstance.getDiagnosticOpts());
     ScanInstance.createDiagnostics(DiagConsumer, /*ShouldOwnClient=*/false);
     if (!ScanInstance.hasDiagnostics())
       return false;
 
     ScanInstance.getPreprocessorOpts().AllowPCHWithDifferentModulesCachePath =
         true;
 
     ScanInstance.getFrontendOpts().GenerateGlobalModuleIndex = false;
     ScanInstance.getFrontendOpts().UseGlobalModuleIndex = false;
     ScanInstance.getFrontendOpts().ModulesShareFileManager = false;
 
     ScanInstance.setFileManager(FileMgr);
     // Support for virtual file system overlays.
     FileMgr->setVirtualFileSystem(createVFSFromCompilerInvocation(
         ScanInstance.getInvocation(), ScanInstance.getDiagnostics(),
         FileMgr->getVirtualFileSystemPtr()));
 
     ScanInstance.createSourceManager(*FileMgr);
 
+    ModuleCache.emplace();
+    ScanInstance.setSimpleModuleCache(ModuleCache.getPointer());
+
     llvm::StringSet<> PrebuiltModulesInputFiles;
     // Store the list of prebuilt module files into header search options. This
     // will prevent the implicit build to create duplicate modules and will
     // force reuse of the existing prebuilt module files instead.
     if (!ScanInstance.getPreprocessorOpts().ImplicitPCHInclude.empty())
       visitPrebuiltModule(
           ScanInstance.getPreprocessorOpts().ImplicitPCHInclude, ScanInstance,
           ScanInstance.getHeaderSearchOpts().PrebuiltModuleFiles,
private:
   DependencyConsumer &Consumer;
   llvm::IntrusiveRefCntPtr<DependencyScanningWorkerFilesystem> DepFS;
   ScanningOutputFormat Format;
   bool OptimizeArgs;
   bool EagerLoadModules;
   bool DisableFree;
   Optional<StringRef> ModuleName;
   Optional<CompilerInstance> ScanInstanceStorage;
+  // TODO: Share this between workers.
+  Optional<SimpleModuleCache> ModuleCache;
   std::shared_ptr<ModuleDepCollector> MDC;
   std::vector<std::string> LastCC1Arguments;
   bool Scanned = false;
 };
 
 } // end anonymous namespace
 
 DependencyScanningWorker::DependencyScanningWorker(

clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp

 //===- ModuleDepCollector.cpp - Callbacks to collect deps -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/DependencyScanning/ModuleDepCollector.h"
 
 #include "clang/Basic/MakeSupport.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/Preprocessor.h"
+#include "clang/Serialization/Simple/ASTReader.h"
+#include "clang/Serialization/Simple/ASTWriter.h"
+#include "clang/Serialization/Simple/ModuleCache.h"
 #include "clang/Tooling/DependencyScanning/DependencyScanningWorker.h"
 #include "llvm/Support/BLAKE3.h"
 #include "llvm/Support/StringSaver.h"
 
 using namespace clang;
 using namespace tooling;
 using namespace dependencies;
 
 static void optimizeHeaderSearchOpts(HeaderSearchOptions &Opts,
-                                     ASTReader &Reader,
-                                     const serialization::ModuleFile &MF) {
+                                     SimpleASTReader &Reader,
+                                     const serialization::SimpleModuleFile &MF) {
   // Only preserve search paths that were used during the dependency scan.
   std::vector<HeaderSearchOptions::Entry> Entries = Opts.UserEntries;
   Opts.UserEntries.clear();
 
   llvm::BitVector SearchPathUsage(Entries.size());
-  llvm::DenseSet<const serialization::ModuleFile *> Visited;
-  std::function<void(const serialization::ModuleFile *)> VisitMF =
-      [&](const serialization::ModuleFile *MF) {
+  llvm::DenseSet<const serialization::SimpleModuleFile *> Visited;
+  std::function<void(const serialization::SimpleModuleFile *)> VisitMF =
+      [&](const serialization::SimpleModuleFile *MF) {
         SearchPathUsage |= MF->SearchPathUsage;
         Visited.insert(MF);
-        for (const serialization::ModuleFile *Import : MF->Imports)
+        for (const serialization::SimpleModuleFile *Import : MF->Imports)
           if (!Visited.contains(Import))
             VisitMF(Import);
       };
   VisitMF(&MF);
 
   for (auto Idx : SearchPathUsage.set_bits())
     Opts.UserEntries.push_back(Entries[Idx]);
 }
for (const Module *M :
     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())
+    if (M->getFullModuleName() == MDC.ScanInstance.getLangOpts().ModuleName)
       continue;
     handleTopLevelModule(M);
   }
 
   MDC.Consumer.handleDependencyOutputOpts(*MDC.Opts);
 
   for (auto &&I : MDC.ModularDeps)
     MDC.Consumer.handleModuleDependency(*I.second);
ModuleID ModuleDepCollectorPP::handleTopLevelModule(const Module *M) {
   if (!ModI.second)
     return ModI.first->second->ID;
 
   ModI.first->second = std::make_unique<ModuleDeps>();
   ModuleDeps &MD = *ModI.first->second;
 
   MD.ID.ModuleName = M->getFullModuleName();
   MD.ImportedByMainFile = DirectModularDeps.contains(M);
-  MD.ImplicitModulePCMPath = std::string(M->getASTFile()->getName());
   MD.IsSystem = M->IsSystem;
 
   ModuleMap &ModMapInfo =
       MDC.ScanInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
 
   Optional<FileEntryRef> ModuleMap = ModMapInfo.getModuleMapFileForUniquing(M);
 
   if (ModuleMap) {
     SmallString<128> Path = ModuleMap->getNameAsRequested();
     ModMapInfo.canonicalizeModuleMapPath(Path);
     MD.ClangModuleMapFile = std::string(Path);
   }
 
-  serialization::ModuleFile *MF =
-      MDC.ScanInstance.getASTReader()->getModuleManager().lookup(
-          M->getASTFile());
-  MDC.ScanInstance.getASTReader()->visitInputFiles(
-      *MF, true, true, [&](const serialization::InputFile &IF, bool isSystem) {
+  serialization::SimpleModuleFile *MF =
+      MDC.ScanInstance.getSimpleASTReader()->getModuleManager().lookup(
+          M->getFullModuleName());
+  if (!MF) {
+    llvm::errs() << "assert MF null for " << M->getFullModuleName() << "\n";
+    std::abort();
+  }
+  MDC.ScanInstance.getSimpleASTReader()->visitInputFiles(
+      *MF, true, true, [&](const serialization::SimpleInputFile &IF, bool isSystem) {
         // __inferred_module.map is the result of the way in which an implicit
         // module build handles inferred modules. It adds an overlay VFS with
         // this file in the proper directory and relies on the rest of Clang to
         // handle it like normal. With explicitly built modules we don't need
         // to play VFS tricks, so replace it with the correct module map.
         if (IF.getFile()->getName().endswith("__inferred_module.map")) {
           MDC.addFileDep(MD, ModuleMap->getName());
           return;
         }
         MDC.addFileDep(MD, IF.getFile()->getName());
       });
 
   llvm::DenseSet<const Module *> SeenDeps;
   addAllSubmodulePrebuiltDeps(M, MD, SeenDeps);
   addAllSubmoduleDeps(M, MD, SeenDeps);
   addAllAffectingClangModules(M, MD, SeenDeps);
 
-  MDC.ScanInstance.getASTReader()->visitTopLevelModuleMaps(
+  MDC.ScanInstance.getSimpleASTReader()->visitTopLevelModuleMaps(
       *MF, [&](const FileEntry *FE) {
         if (FE->getName().endswith("__inferred_module.map"))
           return;
         MD.ModuleMapFileDeps.emplace_back(FE->getName());
       });
 
   CompilerInvocation CI = MDC.makeInvocationForModuleBuildWithoutOutputs(
       MD, [&](CompilerInvocation &BuildInvocation) {
         if (MDC.OptimizeArgs)
           optimizeHeaderSearchOpts(BuildInvocation.getHeaderSearchOpts(),
-                                   *MDC.ScanInstance.getASTReader(), *MF);
+                                   *MDC.ScanInstance.getSimpleASTReader(), *MF);
       });
 
   MDC.associateWithContextHash(CI, MD);
 
   // Finish the compiler invocation. Requires dependencies and the context hash.
   MDC.addOutputPaths(CI, MD);
 
   MD.BuildArguments = CI.getCC1CommandLine();

clang/test/ClangScanDeps/modules-basic.c

+// RUN: rm -rf %t
+// RUN: split-file %s %t
+
+//--- include/module.modulemap
+module top { header "top.h" }
+module left { header "left.h" }
+module right { header "right.h" }
+module right_extra { header "right-extra.h" }
+module bottom { header "bottom.h" }
+//--- include/top.h
+//
+#define D1
+//--- include/left.h
+///
+#include "top.h"
+#define D2
+//--- include/right.h
+////
+#include "right-extra.h"
+#include "top.h"
+#define D3
+//--- include/right-extra.h
+/////
+#define D4
+//--- include/bottom.h
+//////
+#include "left.h"
+#include "right.h"
+#define D5
+//--- include/t.h
+
+//--- tu.c
+#include "bottom.h"
+#ifdef D1
+#endif
+#ifdef D2
+#endif
+#ifdef D3
+#endif
+#ifdef D4
+#endif
+#ifdef D5
+#endif
+
+#define D1
+#define D2
+#define D3
+#define D4
+#define D5
+
+//--- cdb.json.template
+[{
+  "file": "DIR/tu.c",
+  "directory": "DIR",
+  "command": "clang -fsyntax-only DIR/tu.c -fmodules -fmodules-cache-path=DIR/cache -fimplicit-module-maps -I DIR/include"
+}]
+
+// RUN: sed "s|DIR|%/t|g" %t/cdb.json.template > %t/cdb.json
+
+// RUN: clang-scan-deps -compilation-database %t/cdb.json -format experimental-full > %t/result.json
+// RUN: cat %t/result.json | sed 's:\\\\\?:/:g' | FileCheck %s -DPREFIX=%/t
+
+// CHECK:      {
+// CHECK-NEXT:   "modules": [
+// CHECK-NEXT:     {
+// CHECK-NEXT:       "clang-module-deps": [
+// CHECK-NEXT:         {
+// CHECK-NEXT:           "context-hash": "{{.*}}",
+// CHECK-NEXT:           "module-name": "left"
+// CHECK-NEXT:         },
+// CHECK-NEXT:         {
+// CHECK-NEXT:           "context-hash": "{{.*}}",
+// CHECK-NEXT:           "module-name": "right"
+// CHECK-NEXT:         }
+// CHECK-NEXT:       ],
+// CHECK-NEXT:       "clang-modulemap-file": "[[PREFIX]]/include/module.modulemap",
+// CHECK-NEXT:       "command-line": [
+// CHECK:              "-fmodule-map-file=[[PREFIX]]/include/module.modulemap",
+// CHECK:              "-fmodule-file=left=[[PREFIX]]/cache/{{.*}}/left-{{.*}}.pcm",
+// CHECK:              "-fmodule-file=right=[[PREFIX]]/cache/{{.*}}/right-{{.*}}.pcm",
+// CHECK:            ],
+// CHECK-NEXT:       "context-hash": "{{.*}}",
+// CHECK-NEXT:       "file-deps": [
+// CHECK-NEXT:         "[[PREFIX]]/include/bottom.h",
+// CHECK-NEXT:         "[[PREFIX]]/include/module.modulemap"
+// CHECK-NEXT:       ],
+// CHECK-NEXT:       "name": "bottom"
+// CHECK-NEXT:     },
+// CHECK-NEXT:     {
+// CHECK-NEXT:       "clang-module-deps": [
+// CHECK-NEXT:         {
+// CHECK-NEXT:           "context-hash": "{{.*}}",
+// CHECK-NEXT:           "module-name": "top"
+// CHECK-NEXT:         }
+// CHECK-NEXT:       ],
+// CHECK-NEXT:       "clang-modulemap-file": "[[PREFIX]]/include/module.modulemap",
+// CHECK-NEXT:       "command-line": [
+// CHECK:              "-fmodule-map-file=[[PREFIX]]/include/module.modulemap",
+// CHECK:              "-fmodule-file=top=[[PREFIX]]/cache/{{.*}}/top-{{.*}}.pcm",
+// CHECK:            ],
+// CHECK-NEXT:       "context-hash": "{{.*}}",
+// CHECK-NEXT:       "file-deps": [
+// CHECK-NEXT:         "[[PREFIX]]/include/left.h",
+// CHECK-NEXT:         "[[PREFIX]]/include/module.modulemap"
+// CHECK-NEXT:       ],
+// CHECK-NEXT:       "name": "left"
+// CHECK-NEXT:     },
+// CHECK-NEXT:     {
+// CHECK-NEXT:       "clang-module-deps": [
+// CHECK-NEXT:         {
+// CHECK-NEXT:           "context-hash": "{{.*}}",
+// CHECK-NEXT:           "module-name": "right_extra"
+// CHECK-NEXT:         },
+// CHECK-NEXT:         {
+// CHECK-NEXT:           "context-hash": "{{.*}}",
+// CHECK-NEXT:           "module-name": "top"
+// CHECK-NEXT:         }
+// CHECK-NEXT:       ],
+// CHECK-NEXT:       "clang-modulemap-file": "[[PREFIX]]/include/module.modulemap",
+// CHECK-NEXT:       "command-line": [
+// CHECK:              "-fmodule-map-file=[[PREFIX]]/include/module.modulemap",
+// CHECK:              "-fmodule-file=right_extra=[[PREFIX]]/cache/{{.*}}/right_extra-{{.*}}.pcm",
+// CHECK:              "-fmodule-file=top=[[PREFIX]]/cache/{{.*}}/top-{{.*}}.pcm",
+// CHECK:            ],
+// CHECK-NEXT:       "context-hash": "{{.*}}",
+// CHECK-NEXT:       "file-deps": [
+// CHECK-NEXT:         "[[PREFIX]]/include/module.modulemap",
+// CHECK-NEXT:         "[[PREFIX]]/include/right.h"
+// CHECK-NEXT:       ],
+// CHECK-NEXT:       "name": "right"
+// CHECK-NEXT:     },
+// CHECK-NEXT:     {
+// CHECK-NEXT:       "clang-module-deps": [],
+// CHECK-NEXT:       "clang-modulemap-file": "[[PREFIX]]/include/module.modulemap",
+// CHECK-NEXT:       "command-line": [
+// CHECK:            ],
+// CHECK-NEXT:       "context-hash": "{{.*}}",
+// CHECK-NEXT:       "file-deps": [
+// CHECK-NEXT:         "[[PREFIX]]/include/module.modulemap",
+// CHECK-NEXT:         "[[PREFIX]]/include/right-extra.h"
+// CHECK-NEXT:       ],
+// CHECK-NEXT:       "name": "right_extra"
+// CHECK-NEXT:     },
+// CHECK-NEXT:     {
+// CHECK-NEXT:       "clang-module-deps": [],
+// CHECK-NEXT:       "clang-modulemap-file": "[[PREFIX]]/include/module.modulemap",
+// CHECK-NEXT:       "command-line": [
+// CHECK:            ],
+// CHECK-NEXT:       "context-hash": "{{.*}}",
+// CHECK-NEXT:       "file-deps": [
+// CHECK-NEXT:         "[[PREFIX]]/include/module.modulemap",
+// CHECK-NEXT:         "[[PREFIX]]/include/top.h"
+// CHECK-NEXT:       ],
+// CHECK-NEXT:       "name": "top"
+// CHECK-NEXT:     }
+// CHECK-NEXT:   ],
+// CHECK-NEXT:   "translation-units": [
+// CHECK-NEXT:     {
+// CHECK-NEXT:       "commands": [
+// CHECK-NEXT:         {
+// CHECK-NEXT:           "clang-context-hash": "{{.*}}",
+// CHECK-NEXT:           "clang-module-deps": [
+// CHECK-NEXT:             {
+// CHECK-NEXT:               "context-hash": "{{.*}}",
+// CHECK-NEXT:               "module-name": "bottom"
+// CHECK-NEXT:             }
+// CHECK-NEXT:           ],
+// CHECK-NEXT:           "command-line": [
+// CHECK:                  "-fmodule-map-file=[[PREFIX]]/include/module.modulemap",
+// CHECK:                  "-fmodule-file=bottom=[[PREFIX]]/cache/{{.*}}/bottom-{{.*}}.pcm",
+// CHECK:                ],
+// CHECK-NEXT:           "executable": "clang",
+// CHECK-NEXT:           "file-deps": [
+// CHECK-NEXT:             "[[PREFIX]]/tu.c"
+// CHECK-NEXT:           ],
+// CHECK-NEXT:           "input-file": "[[PREFIX]]/tu.c"
+// CHECK-NEXT:         }
+// CHECK-NEXT:       ]
+// CHECK-NEXT:     }
+// CHECK-NEXT:   ]
+// CHECK-NEXT: }