clang-tools-extra/clang-tidy/ExpandModularHeadersPPCallbacks.cpp

   1 //===- ExpandModularHeadersPPCallbacks.h - clang-tidy -----------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "ExpandModularHeadersPPCallbacks.h"
  10 #include "clang/Basic/FileManager.h"
  11 #include "clang/Basic/TargetInfo.h"
  12 #include "clang/Frontend/CompilerInstance.h"
  13 #include "clang/Lex/PreprocessorOptions.h"
  14 #include "clang/Serialization/ASTReader.h"
  15 #include <optional>
  16
  17 #define DEBUG_TYPE "clang-tidy"
  18
  19 namespace clang::tooling {
  20
  21 class ExpandModularHeadersPPCallbacks::FileRecorder {
  22 public:
  23   /// Records that a given file entry is needed for replaying callbacks.
  24   void addNecessaryFile(FileEntryRef File) {
  25     // Don't record modulemap files because it breaks same file detection.
  26     if (!(File.getName().endswith("module.modulemap") ||
  27           File.getName().endswith("module.private.modulemap") ||
  28           File.getName().endswith("module.map") ||
  29           File.getName().endswith("module_private.map")))
  30       FilesToRecord.insert(File);
  31   }
  32
  33   /// Records content for a file and adds it to the FileSystem.
  34   void recordFileContent(FileEntryRef File,
  35                          const SrcMgr::ContentCache &ContentCache,
  36                          llvm::vfs::InMemoryFileSystem &InMemoryFs) {
  37     // Return if we are not interested in the contents of this file.
  38     if (!FilesToRecord.count(File))
  39       return;
  40
  41     // FIXME: Why is this happening? We might be losing contents here.
  42     std::optional<StringRef> Data = ContentCache.getBufferDataIfLoaded();
  43     if (!Data)
  44       return;
  45
  46     InMemoryFs.addFile(File.getName(), /*ModificationTime=*/0,
  47                        llvm::MemoryBuffer::getMemBufferCopy(*Data));
  48     // Remove the file from the set of necessary files.
  49     FilesToRecord.erase(File);
  50   }
  51
  52   /// Makes sure we have contents for all the files we were interested in. Ideally
  53   /// `FilesToRecord` should be empty.
  54   void checkAllFilesRecorded() {
  55     LLVM_DEBUG({
  56       for (auto FileEntry : FilesToRecord)
  57         llvm::dbgs() << "Did not record contents for input file: "
  58                      << FileEntry.getName() << "\n";
  59     });
  60   }
  61
  62 private:
  63   /// A set of files whose contents are to be recorded.
  64   llvm::DenseSet<FileEntryRef> FilesToRecord;
  65 };
  66
  67 ExpandModularHeadersPPCallbacks::ExpandModularHeadersPPCallbacks(
  68     CompilerInstance *CI,
  69     IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFS)
  70     : Recorder(std::make_unique<FileRecorder>()), Compiler(*CI),
  71       InMemoryFs(new llvm::vfs::InMemoryFileSystem),
  72       Sources(Compiler.getSourceManager()),
  73       // Forward the new diagnostics to the original DiagnosticConsumer.
  74       Diags(new DiagnosticIDs, new DiagnosticOptions,
  75             new ForwardingDiagnosticConsumer(Compiler.getDiagnosticClient())),
  76       LangOpts(Compiler.getLangOpts()) {
  77   // Add a FileSystem containing the extra files needed in place of modular
  78   // headers.
  79   OverlayFS->pushOverlay(InMemoryFs);
  80
  81   Diags.setSourceManager(&Sources);
  82   // FIXME: Investigate whatever is there better way to initialize DiagEngine
  83   // or whatever DiagEngine can be shared by multiple preprocessors
  84   ProcessWarningOptions(Diags, Compiler.getDiagnosticOpts());
  85
  86   LangOpts.Modules = false;
  87
  88   auto HSO = std::make_shared<HeaderSearchOptions>();
  89   *HSO = Compiler.getHeaderSearchOpts();
  90
  91   HeaderInfo = std::make_unique<HeaderSearch>(HSO, Sources, Diags, LangOpts,
  92                                                &Compiler.getTarget());
  93
  94   auto PO = std::make_shared<PreprocessorOptions>();
  95   *PO = Compiler.getPreprocessorOpts();
  96
  97   PP = std::make_unique<clang::Preprocessor>(PO, Diags, LangOpts, Sources,
  98                                               *HeaderInfo, ModuleLoader,
  99                                               /*IILookup=*/nullptr,
 100                                               /*OwnsHeaderSearch=*/false);
 101   PP->Initialize(Compiler.getTarget(), Compiler.getAuxTarget());
 102   InitializePreprocessor(*PP, *PO, Compiler.getPCHContainerReader(),
 103                          Compiler.getFrontendOpts());
 104   ApplyHeaderSearchOptions(*HeaderInfo, *HSO, LangOpts,
 105                            Compiler.getTarget().getTriple());
 106 }
 107
 108 ExpandModularHeadersPPCallbacks::~ExpandModularHeadersPPCallbacks() = default;
 109
 110 Preprocessor *ExpandModularHeadersPPCallbacks::getPreprocessor() const {
 111   return PP.get();
 112 }
 113
 114 void ExpandModularHeadersPPCallbacks::handleModuleFile(
 115     serialization::ModuleFile *MF) {
 116   if (!MF)
 117     return;
 118   // Avoid processing a ModuleFile more than once.
 119   if (VisitedModules.count(MF))
 120     return;
 121   VisitedModules.insert(MF);
 122
 123   // Visit all the input files of this module and mark them to record their
 124   // contents later.
 125   Compiler.getASTReader()->visitInputFiles(
 126       *MF, true, false,
 127       [this](const serialization::InputFile &IF, bool /*IsSystem*/) {
 128         Recorder->addNecessaryFile(*IF.getFile());
 129       });
 130   // Recursively handle all transitively imported modules.
 131   for (auto *Import : MF->Imports)
 132     handleModuleFile(Import);
 133 }
 134
 135 void ExpandModularHeadersPPCallbacks::parseToLocation(SourceLocation Loc) {
 136   // Load all source locations present in the external sources.
 137   for (unsigned I = 0, N = Sources.loaded_sloc_entry_size(); I != N; ++I) {
 138     Sources.getLoadedSLocEntry(I, nullptr);
 139   }
 140   // Record contents of files we are interested in and add to the FileSystem.
 141   for (auto It = Sources.fileinfo_begin(); It != Sources.fileinfo_end(); ++It) {
 142     Recorder->recordFileContent(It->getFirst(), *It->getSecond(), *InMemoryFs);
 143   }
 144   Recorder->checkAllFilesRecorded();
 145
 146   if (!StartedLexing) {
 147     StartedLexing = true;
 148     PP->Lex(CurrentToken);
 149   }
 150   while (!CurrentToken.is(tok::eof) &&
 151          Sources.isBeforeInTranslationUnit(CurrentToken.getLocation(), Loc)) {
 152     PP->Lex(CurrentToken);
 153   }
 154 }
 155
 156 void ExpandModularHeadersPPCallbacks::FileChanged(
 157     SourceLocation Loc, FileChangeReason Reason,
 158     SrcMgr::CharacteristicKind FileType, FileID PrevFID = FileID()) {
 159   if (!EnteredMainFile) {
 160     EnteredMainFile = true;
 161     PP->EnterMainSourceFile();
 162   }
 163 }
 164
 165 void ExpandModularHeadersPPCallbacks::InclusionDirective(
 166     SourceLocation DirectiveLoc, const Token &IncludeToken,
 167     StringRef IncludedFilename, bool IsAngled, CharSourceRange FilenameRange,
 168     OptionalFileEntryRef IncludedFile, StringRef SearchPath,
 169     StringRef RelativePath, const Module *Imported,
 170     SrcMgr::CharacteristicKind FileType) {
 171   if (Imported) {
 172     serialization::ModuleFile *MF =
 173         Compiler.getASTReader()->getModuleManager().lookup(
 174             Imported->getASTFile());
 175     handleModuleFile(MF);
 176   }
 177   parseToLocation(DirectiveLoc);
 178 }
 179
 180 void ExpandModularHeadersPPCallbacks::EndOfMainFile() {
 181   while (!CurrentToken.is(tok::eof))
 182     PP->Lex(CurrentToken);
 183 }
 184
 185 // Handle all other callbacks.
 186 // Just parse to the corresponding location to generate the same callback for
 187 // the PPCallbacks registered in our custom preprocessor.
 188 void ExpandModularHeadersPPCallbacks::Ident(SourceLocation Loc, StringRef) {
 189   parseToLocation(Loc);
 190 }
 191 void ExpandModularHeadersPPCallbacks::PragmaDirective(SourceLocation Loc,
 192                                                       PragmaIntroducerKind) {
 193   parseToLocation(Loc);
 194 }
 195 void ExpandModularHeadersPPCallbacks::PragmaComment(SourceLocation Loc,
 196                                                     const IdentifierInfo *,
 197                                                     StringRef) {
 198   parseToLocation(Loc);
 199 }
 200 void ExpandModularHeadersPPCallbacks::PragmaDetectMismatch(SourceLocation Loc,
 201                                                            StringRef,
 202                                                            StringRef) {
 203   parseToLocation(Loc);
 204 }
 205 void ExpandModularHeadersPPCallbacks::PragmaDebug(SourceLocation Loc,
 206                                                   StringRef) {
 207   parseToLocation(Loc);
 208 }
 209 void ExpandModularHeadersPPCallbacks::PragmaMessage(SourceLocation Loc,
 210                                                     StringRef,
 211                                                     PragmaMessageKind,
 212                                                     StringRef) {
 213   parseToLocation(Loc);
 214 }
 215 void ExpandModularHeadersPPCallbacks::PragmaDiagnosticPush(SourceLocation Loc,
 216                                                            StringRef) {
 217   parseToLocation(Loc);
 218 }
 219 void ExpandModularHeadersPPCallbacks::PragmaDiagnosticPop(SourceLocation Loc,
 220                                                           StringRef) {
 221   parseToLocation(Loc);
 222 }
 223 void ExpandModularHeadersPPCallbacks::PragmaDiagnostic(SourceLocation Loc,
 224                                                        StringRef,
 225                                                        diag::Severity,
 226                                                        StringRef) {
 227   parseToLocation(Loc);
 228 }
 229 void ExpandModularHeadersPPCallbacks::HasInclude(SourceLocation Loc, StringRef,
 230                                                  bool, OptionalFileEntryRef,
 231                                                  SrcMgr::CharacteristicKind) {
 232   parseToLocation(Loc);
 233 }
 234 void ExpandModularHeadersPPCallbacks::PragmaOpenCLExtension(
 235     SourceLocation NameLoc, const IdentifierInfo *, SourceLocation StateLoc,
 236     unsigned) {
 237   // FIXME: Figure out whether it's the right location to parse to.
 238   parseToLocation(NameLoc);
 239 }
 240 void ExpandModularHeadersPPCallbacks::PragmaWarning(SourceLocation Loc,
 241                                                     PragmaWarningSpecifier,
 242                                                     ArrayRef<int>) {
 243   parseToLocation(Loc);
 244 }
 245 void ExpandModularHeadersPPCallbacks::PragmaWarningPush(SourceLocation Loc,
 246                                                         int) {
 247   parseToLocation(Loc);
 248 }
 249 void ExpandModularHeadersPPCallbacks::PragmaWarningPop(SourceLocation Loc) {
 250   parseToLocation(Loc);
 251 }
 252 void ExpandModularHeadersPPCallbacks::PragmaAssumeNonNullBegin(
 253     SourceLocation Loc) {
 254   parseToLocation(Loc);
 255 }
 256 void ExpandModularHeadersPPCallbacks::PragmaAssumeNonNullEnd(
 257     SourceLocation Loc) {
 258   parseToLocation(Loc);
 259 }
 260 void ExpandModularHeadersPPCallbacks::MacroExpands(const Token &MacroNameTok,
 261                                                    const MacroDefinition &,
 262                                                    SourceRange Range,
 263                                                    const MacroArgs *) {
 264   // FIXME: Figure out whether it's the right location to parse to.
 265   parseToLocation(Range.getBegin());
 266 }
 267 void ExpandModularHeadersPPCallbacks::MacroDefined(const Token &MacroNameTok,
 268                                                    const MacroDirective *MD) {
 269   parseToLocation(MD->getLocation());
 270 }
 271 void ExpandModularHeadersPPCallbacks::MacroUndefined(
 272     const Token &, const MacroDefinition &, const MacroDirective *Undef) {
 273   if (Undef)
 274     parseToLocation(Undef->getLocation());
 275 }
 276 void ExpandModularHeadersPPCallbacks::Defined(const Token &MacroNameTok,
 277                                               const MacroDefinition &,
 278                                               SourceRange Range) {
 279   // FIXME: Figure out whether it's the right location to parse to.
 280   parseToLocation(Range.getBegin());
 281 }
 282 void ExpandModularHeadersPPCallbacks::SourceRangeSkipped(
 283     SourceRange Range, SourceLocation EndifLoc) {
 284   // FIXME: Figure out whether it's the right location to parse to.
 285   parseToLocation(EndifLoc);
 286 }
 287 void ExpandModularHeadersPPCallbacks::If(SourceLocation Loc, SourceRange,
 288                                          ConditionValueKind) {
 289   parseToLocation(Loc);
 290 }
 291 void ExpandModularHeadersPPCallbacks::Elif(SourceLocation Loc, SourceRange,
 292                                            ConditionValueKind, SourceLocation) {
 293   parseToLocation(Loc);
 294 }
 295 void ExpandModularHeadersPPCallbacks::Ifdef(SourceLocation Loc, const Token &,
 296                                             const MacroDefinition &) {
 297   parseToLocation(Loc);
 298 }
 299 void ExpandModularHeadersPPCallbacks::Ifndef(SourceLocation Loc, const Token &,
 300                                              const MacroDefinition &) {
 301   parseToLocation(Loc);
 302 }
 303 void ExpandModularHeadersPPCallbacks::Else(SourceLocation Loc, SourceLocation) {
 304   parseToLocation(Loc);
 305 }
 306 void ExpandModularHeadersPPCallbacks::Endif(SourceLocation Loc,
 307                                             SourceLocation) {
 308   parseToLocation(Loc);
 309 }
 310
 311 } // namespace clang::tooling