[Tooling/DependencyScanning] Rename refactorings towards transitioning dependency scanning to use pre-lexed preprocessor directive tokens

[akyrtzi]

Summary

This is 1/4 of a series of patches for making the special lexing for dependency scanning a first-class feature of the Preprocessor and Lexer.
This patch only includes NFC renaming changes to make reviewing of the functionality changing parts easier.

[jansvoboda11]

LGTM! Thanks for splitting this out.

clang/tools/clang-scan-deps/ClangScanDeps.cpp

120

Probably unnecessary bike-shedding, but something like preprocess-dependency-directives or scan-and-preprocess-dependency-directives would read better IMO. Up to you whether you change this.

[akyrtzi]

Rename the clang-scan-deps flag from "-preprocess-directives-scan" to "-preprocess-dependency-directives"

[akyrtzi]

clang/tools/clang-scan-deps/ClangScanDeps.cpp

120

preprocess-dependency-directives is indeed better, I've renamed the flag to that 👍

clang/include/clang/Basic/DiagnosticLexKinds.td

 def err_pp_include_in_assume_nonnull : Error<
   "cannot %select{#include files|import headers}0 "
   "inside '#pragma clang assume_nonnull'">;
 def err_pp_eof_in_assume_nonnull : Error<
   "'#pragma clang assume_nonnull' was not ended within this file">;
 
 }
 
-let CategoryName = "Dependency Directive Source Minimization Issue" in {
+let CategoryName = "Dependency Directive Source Scanner Issue" in {
 
-def err_dep_source_minimizer_missing_sema_after_at_import : Error<
+def err_dep_source_scanner_missing_semi_after_at_import : Error<
   "could not find ';' after @import">;
-def err_dep_source_minimizer_unexpected_tokens_at_import : Error<
+def err_dep_source_scanner_unexpected_tokens_at_import : Error<
   "unexpected extra tokens at end of @import declaration">;
 
 }
 
 }

clang/include/clang/Lex/DependencyDirectivesScanner.h

-//===- clang/Lex/DependencyDirectivesSourceMinimizer.h -  ----------*- C++ -*-//
+//===- clang/Lex/DependencyDirectivesScanner.h ---------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// This is the interface for minimizing header and source files to the
+/// This is the interface for scanning header and source files to get the
 /// minimum necessary preprocessor directives for evaluating includes. It
 /// reduces the source down to #define, #include, #import, @import, and any
 /// conditional preprocessor logic that contains one of those.
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_LEX_DEPENDENCYDIRECTIVESSOURCEMINIMIZER_H
-#define LLVM_CLANG_LEX_DEPENDENCYDIRECTIVESSOURCEMINIMIZER_H
+#ifndef LLVM_CLANG_LEX_DEPENDENCYDIRECTIVESSCANNER_H
+#define LLVM_CLANG_LEX_DEPENDENCYDIRECTIVESSCANNER_H
 
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace clang {
 
 class DiagnosticsEngine;
 
-namespace minimize_source_to_dependency_directives {
+namespace dependency_directives_scan {
 
 /// Represents the kind of preprocessor directive or a module declaration that
-/// is tracked by the source minimizer in its token output.
-enum TokenKind {
+/// is tracked by the scanner in its token output.
+enum DirectiveKind : uint8_t {
   pp_none,
   pp_include,
   pp___include_macros,
   pp_define,
   pp_undef,
   pp_import,
   pp_pragma_import,
   pp_pragma_once,
enum DirectiveKind : uint8_t {
   pp_endif,
   decl_at_import,
   cxx_export_decl,
   cxx_module_decl,
   cxx_import_decl,
   pp_eof,
 };
 
-/// Represents a simplified token that's lexed as part of the source
-/// minimization. It's used to track the location of various preprocessor
-/// directives that could potentially have an effect on the depedencies.
-struct Token {
+/// Represents a directive that's lexed as part of the dependency directives
+/// scanning. It's used to track various preprocessor directives that could
+/// potentially have an effect on the depedencies.
+struct Directive {
   /// The kind of token.
-  TokenKind K = pp_none;
+  DirectiveKind Kind = pp_none;
 
   /// Offset into the output byte stream of where the directive begins.
   int Offset = -1;
 
-  Token(TokenKind K, int Offset) : K(K), Offset(Offset) {}
+  Directive(DirectiveKind K, int Offset) : Kind(K), Offset(Offset) {}
 };
 
 /// Simplified token range to track the range of a potentially skippable PP
 /// directive.
 struct SkippedRange {
   /// Offset into the output byte stream of where the skipped directive begins.
   int Offset;
 
   /// The number of bytes that can be skipped before the preprocessing must
   /// resume.
   int Length;
 };
 
 /// Computes the potential source ranges that can be skipped by the preprocessor
 /// when skipping a directive like #if, #ifdef or #elsif.
 ///
 /// \returns false on success, true on error.
-bool computeSkippedRanges(ArrayRef<Token> Input,
+bool computeSkippedRanges(ArrayRef<Directive> Input,
                           llvm::SmallVectorImpl<SkippedRange> &Range);
 
-} // end namespace minimize_source_to_dependency_directives
+} // end namespace dependency_directives_scan
 
 /// Minimize the input down to the preprocessor directives that might have
 /// an effect on the dependencies for a compilation unit.
 ///
 /// This function deletes all non-preprocessor code, and strips anything that
 /// can't affect what gets included. It canonicalizes whitespace where
 /// convenient to stabilize the output against formatting changes in the input.
 ///
 /// Clears the output vectors at the beginning of the call.
 ///
 /// \returns false on success, true on error. If the diagnostic engine is not
 /// null, an appropriate error is reported using the given input location
 /// with the offset that corresponds to the minimizer's current buffer offset.
-bool minimizeSourceToDependencyDirectives(
+bool scanSourceForDependencyDirectives(
     llvm::StringRef Input, llvm::SmallVectorImpl<char> &Output,
-    llvm::SmallVectorImpl<minimize_source_to_dependency_directives::Token>
-        &Tokens,
+    llvm::SmallVectorImpl<dependency_directives_scan::Directive> &Directives,
     DiagnosticsEngine *Diags = nullptr,
     SourceLocation InputSourceLoc = SourceLocation());
 
 } // end namespace clang
 
-#endif // LLVM_CLANG_LEX_DEPENDENCYDIRECTIVESSOURCEMINIMIZER_H
+#endif // LLVM_CLANG_LEX_DEPENDENCYDIRECTIVESSCANNER_H

clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h

 namespace dependencies {
 
 /// Original and minimized contents of a cached file entry. Single instance can
 /// be shared between multiple entries.
 struct CachedFileContents {
   CachedFileContents(std::unique_ptr<llvm::MemoryBuffer> Original)
       : Original(std::move(Original)), MinimizedAccess(nullptr) {}
 
-  /// Owning storage for the minimized contents.
+  /// Owning storage for the original contents.
   std::unique_ptr<llvm::MemoryBuffer> Original;
 
-  /// The mutex that must be locked before mutating minimized contents.
+  /// The mutex that must be locked before mutating directive tokens.
   std::mutex ValueLock;
   /// Owning storage for the minimized contents.
   std::unique_ptr<llvm::MemoryBuffer> MinimizedStorage;
-  /// Accessor to the minimized contents that's atomic to avoid data races.
+  /// Accessor to the directive tokens that's atomic to avoid data races.
   std::atomic<llvm::MemoryBuffer *> MinimizedAccess;
   /// Skipped range mapping of the minimized contents.
   /// This is initialized iff `MinimizedAccess != nullptr`.
   PreprocessorSkippedRangeMapping PPSkippedRangeMapping;
 };
 
 /// An in-memory representation of a file system entity that is of interest to
 /// the dependency scanning filesystem.
 ///
 /// It represents one of the following:
-/// - opened file with original contents and a stat value,
-/// - opened file with original contents, minimized contents and a stat value,
+/// - opened file with contents and a stat value,
+/// - opened file with contents, directive tokens and a stat value,
 /// - directory entry with its stat value,
 /// - filesystem error.
 ///
 /// Single instance of this class can be shared across different filenames (e.g.
 /// a regular file and a symlink). For this reason the status filename is empty
 /// and is only materialized by \c EntryRef that knows the requested filename.
 class CachedFileSystemEntry {
 public:
public:
   /// \returns Original contents of the file.
   StringRef getOriginalContents() const {
     assert(!isError() && "error");
     assert(!MaybeStat->isDirectory() && "not a file");
     assert(Contents && "contents not initialized");
     return Contents->Original->getBuffer();
   }
 
-  /// \returns Minimized contents of the file.
-  StringRef getMinimizedContents() const {
+  /// \returns The scanned preprocessor directive tokens of the file that are
+  /// used to speed up preprocessing, if available.
+  StringRef getDirectiveTokens() const {
     assert(!isError() && "error");
     assert(!MaybeStat->isDirectory() && "not a file");
     assert(Contents && "contents not initialized");
     llvm::MemoryBuffer *Buffer = Contents->MinimizedAccess.load();
     assert(Buffer && "not minimized");
     return Buffer->getBuffer();
   }
 
public:
   /// the block skipping in the preprocessor.
   const PreprocessorSkippedRangeMapping &getPPSkippedRangeMapping() const {
     assert(!isError() && "error");
     assert(!isDirectory() && "not a file");
     assert(Contents && "contents not initialized");
     return Contents->PPSkippedRangeMapping;
   }
 
-  /// \returns The data structure holding both original and minimized contents.
-  CachedFileContents *getContents() const {
+  /// \returns The data structure holding both contents and directive tokens.
+  CachedFileContents *getCachedContents() const {
     assert(!isError() && "error");
     assert(!isDirectory() && "not a file");
     return Contents;
   }
 
 private:
   void clearStatName() {
     if (MaybeStat)
       MaybeStat = llvm::vfs::Status::copyWithNewName(*MaybeStat, "");
   }
 
   /// Either the filesystem error or status of the entry.
   /// The filename is empty and only materialized by \c EntryRef.
   llvm::ErrorOr<llvm::vfs::Status> MaybeStat;
 
   /// Non-owning pointer to the file contents.
   ///
   /// We're using pointer here to keep the size of this class small. Instances
   /// representing directories and filesystem errors don't hold any contents
   /// anyway.
   CachedFileContents *Contents;
 };
 
 /// This class is a shared cache, that caches the 'stat' and 'open' calls to the
-/// underlying real file system. It distinguishes between minimized and original
+/// underlying real file system, and the scanned preprocessor directives of
 /// files.
 ///
 /// It is sharded based on the hash of the key to reduce the lock contention for
 /// the worker threads.
 class DependencyScanningFilesystemSharedCache {
 public:
   struct CacheShard {
     /// The mutex that needs to be locked before mutation of any member.
public:
   CacheShard &getShardForUID(llvm::sys::fs::UniqueID UID) const;
 
 private:
   std::unique_ptr<CacheShard[]> CacheShards;
   unsigned NumShards;
 };
 
 /// This class is a local cache, that caches the 'stat' and 'open' calls to the
-/// underlying real file system. It distinguishes between minimized and original
-/// files.
+/// underlying real file system.
 class DependencyScanningFilesystemLocalCache {
   llvm::StringMap<const CachedFileSystemEntry *, llvm::BumpPtrAllocator> Cache;
 
 public:
   /// Returns entry associated with the filename or nullptr if none is found.
   const CachedFileSystemEntry *findEntryByFilename(StringRef Filename) const {
     auto It = Cache.find(Filename);
     return It == Cache.end() ? nullptr : It->getValue();
   }
 
   /// Associates the given entry with the filename and returns the given entry
   /// pointer (for convenience).
   const CachedFileSystemEntry &
   insertEntryForFilename(StringRef Filename,
                          const CachedFileSystemEntry &Entry) {
     const auto *InsertedEntry = Cache.insert({Filename, &Entry}).first->second;
     assert(InsertedEntry == &Entry && "entry already present");
     return *InsertedEntry;
   }
 };
 
 /// Reference to a CachedFileSystemEntry.
-/// If the underlying entry is an opened file, this wrapper returns the correct
-/// contents (original or minimized) and ensures consistency with file size
-/// reported by status.
+/// If the underlying entry is an opened file, this wrapper returns the file
+/// contents and the scanned preprocessor directives.
 class EntryRef {
   /// For entry that is an opened file, this bit signifies whether its contents
   /// are minimized.
   bool Minimized;
 
   /// The filename used to access this entry.
   std::string Filename;
 
public:
   /// If the cached entry represents an error, promotes it into `ErrorOr`.
   llvm::ErrorOr<EntryRef> unwrapError() const {
     if (isError())
       return Entry.getError();
     return *this;
   }
 
   StringRef getContents() const {
-    return Minimized ? Entry.getMinimizedContents()
-                     : Entry.getOriginalContents();
+    return Minimized ? Entry.getDirectiveTokens() : Entry.getOriginalContents();
   }
 
   const PreprocessorSkippedRangeMapping *getPPSkippedRangeMapping() const {
     return Minimized ? &Entry.getPPSkippedRangeMapping() : nullptr;
   }
 };
 
 /// A virtual file system optimized for the dependency discovery.
DependencyScanningWorkerFilesystem(
       ExcludedPreprocessorDirectiveSkipMapping &PPSkipMappings)
       : ProxyFileSystem(std::move(FS)), SharedCache(SharedCache),
         PPSkipMappings(PPSkipMappings) {}
 
   llvm::ErrorOr<llvm::vfs::Status> status(const Twine &Path) override;
   llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>>
   openFileForRead(const Twine &Path) override;
 
-  /// Disable minimization of the given file.
-  void disableMinimization(StringRef Filename);
-  /// Enable minimization of all files.
-  void enableMinimizationOfAllFiles() { NotToBeMinimized.clear(); }
+  /// Disable directives scanning of the given file.
+  void disableDirectivesScanning(StringRef Filename);
+  /// Enable directives scanning of all files.
+  void enableDirectivesScanningOfAllFiles() { NotToBeScanned.clear(); }
 
 private:
-  /// Check whether the file should be minimized.
-  bool shouldMinimize(StringRef Filename, llvm::sys::fs::UniqueID UID);
+  /// Check whether the file should be scanned for preprocessor directives.
+  bool shouldScanForDirectives(StringRef Filename, llvm::sys::fs::UniqueID UID);
 
   /// Returns entry for the given filename.
   ///
   /// Attempts to use the local and shared caches first, then falls back to
   /// using the underlying filesystem.
   llvm::ErrorOr<EntryRef>
   getOrCreateFileSystemEntry(StringRef Filename,
-                             bool DisableMinimization = false);
+                             bool DisableDirectivesScanning = false);
 
   /// For a filename that's not yet associated with any entry in the caches,
   /// uses the underlying filesystem to either look up the entry based in the
   /// shared cache indexed by unique ID, or creates new entry from scratch.
   llvm::ErrorOr<const CachedFileSystemEntry &>
   computeAndStoreResult(StringRef Filename);
 
-  /// Minimizes the given entry if necessary and returns a wrapper object with
-  /// reference semantics.
-  EntryRef minimizeIfNecessary(const CachedFileSystemEntry &Entry,
+  /// Scan for preprocessor directives for the given entry if necessary and
+  /// returns a wrapper object with reference semantics.
+  EntryRef scanForDirectivesIfNecessary(const CachedFileSystemEntry &Entry,
                                         StringRef Filename, bool Disable);
 
   /// Represents a filesystem entry that has been stat-ed (and potentially read)
   /// and that's about to be inserted into the cache as `CachedFileSystemEntry`.
   struct TentativeEntry {
     llvm::vfs::Status Status;
     std::unique_ptr<llvm::MemoryBuffer> Contents;
 
     TentativeEntry(llvm::vfs::Status Status,
private:
   DependencyScanningFilesystemSharedCache &SharedCache;
   /// The local cache is used by the worker thread to cache file system queries
   /// locally instead of querying the global cache every time.
   DependencyScanningFilesystemLocalCache LocalCache;
   /// The mapping structure which records information about the
   /// excluded conditional directive skip mappings that are used by the
   /// currently active preprocessor.
   ExcludedPreprocessorDirectiveSkipMapping &PPSkipMappings;
-  /// The set of files that should not be minimized.
-  llvm::DenseSet<llvm::sys::fs::UniqueID> NotToBeMinimized;
+  /// The set of files that should not be scanned for PP directives.
+  llvm::DenseSet<llvm::sys::fs::UniqueID> NotToBeScanned;
 };
 
 } // end namespace dependencies
 } // end namespace tooling
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLING_DEPENDENCYSCANNING_DEPENDENCYSCANNINGFILESYSTEM_H

clang/include/clang/Tooling/DependencyScanning/DependencyScanningService.h

 namespace clang {
 namespace tooling {
 namespace dependencies {
 
 /// The mode in which the dependency scanner will operate to find the
 /// dependencies.
 enum class ScanningMode {
   /// This mode is used to compute the dependencies by running the preprocessor
-  /// over
-  /// the unmodified source files.
+  /// over the source files.
   CanonicalPreprocessing,
 
   /// This mode is used to compute the dependencies by running the preprocessor
-  /// over
-  /// the source files that have been minimized to contents that might affect
-  /// the dependencies.
-  MinimizedSourcePreprocessing
+  /// with special kind of lexing after scanning header and source files to get
+  /// the minimum necessary preprocessor directives for evaluating includes.
+  DependencyDirectivesScan,
 };
 
 /// The format that is output by the dependency scanner.
 enum class ScanningOutputFormat {
   /// This is the Makefile compatible dep format. This will include all of the
   /// deps necessary for an implicit modules build, but won't include any
   /// intermodule dependency information.
   Make,

clang/lib/Frontend/FrontendActions.cpp

 #include "clang/Basic/LangStandard.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Frontend/ASTConsumers.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/MultiplexConsumer.h"
 #include "clang/Frontend/Utils.h"
-#include "clang/Lex/DependencyDirectivesSourceMinimizer.h"
+#include "clang/Lex/DependencyDirectivesScanner.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Sema/TemplateInstCallback.h"
 #include "clang/Serialization/ASTReader.h"
 #include "clang/Serialization/ASTWriter.h"
 #include "clang/Serialization/ModuleFile.h"
 #include "llvm/Support/ErrorHandling.h"

 }
 
 void PrintDependencyDirectivesSourceMinimizerAction::ExecuteAction() {
   CompilerInstance &CI = getCompilerInstance();
   SourceManager &SM = CI.getPreprocessor().getSourceManager();
   llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
 
   llvm::SmallString<1024> Output;
-  llvm::SmallVector<minimize_source_to_dependency_directives::Token, 32> Toks;
-  if (minimizeSourceToDependencyDirectives(
-          FromFile.getBuffer(), Output, Toks, &CI.getDiagnostics(),
+  llvm::SmallVector<dependency_directives_scan::Directive, 32> Directives;
+  if (scanSourceForDependencyDirectives(
+          FromFile.getBuffer(), Output, Directives, &CI.getDiagnostics(),
           SM.getLocForStartOfFile(SM.getMainFileID()))) {
     assert(CI.getDiagnostics().hasErrorOccurred() &&
            "no errors reported for failure");
 
     // Preprocess the source when verifying the diagnostics to capture the
     // 'expected' comments.
     if (CI.getDiagnosticOpts().VerifyDiagnostics) {
       // Make sure we don't emit new diagnostics!

clang/lib/Lex/CMakeLists.txt

 # TODO: Add -maltivec when ARCH is PowerPC.
 
 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangLex
-  DependencyDirectivesSourceMinimizer.cpp
+  DependencyDirectivesScanner.cpp
   HeaderMap.cpp
   HeaderSearch.cpp
   InitHeaderSearch.cpp
   Lexer.cpp
   LiteralSupport.cpp
   MacroArgs.cpp
   MacroInfo.cpp
   ModuleMap.cpp

clang/lib/Lex/DependencyDirectivesScanner.cpp

-//===- DependencyDirectivesSourceMinimizer.cpp -  -------------------------===//
+//===- DependencyDirectivesScanner.cpp ------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// This is the implementation for minimizing header and source files to the
+/// This is the interface for scanning header and source files to get the
 /// minimum necessary preprocessor directives for evaluating includes. It
 /// reduces the source down to #define, #include, #import, @import, and any
 /// conditional preprocessor logic that contains one of those.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "clang/Lex/DependencyDirectivesSourceMinimizer.h"
+#include "clang/Lex/DependencyDirectivesScanner.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Lex/LexDiagnostic.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 using namespace llvm;
 using namespace clang;
-using namespace clang::minimize_source_to_dependency_directives;
+using namespace clang::dependency_directives_scan;
 
 namespace {
 
-struct Minimizer {
+struct Scanner {
   /// Minimized output.
   SmallVectorImpl<char> &Out;
   /// The known tokens encountered during the minimization.
-  SmallVectorImpl<Token> &Tokens;
+  SmallVectorImpl<Directive> &Directives;
 
-  Minimizer(SmallVectorImpl<char> &Out, SmallVectorImpl<Token> &Tokens,
-            StringRef Input, DiagnosticsEngine *Diags,
-            SourceLocation InputSourceLoc)
-      : Out(Out), Tokens(Tokens), Input(Input), Diags(Diags),
+  Scanner(SmallVectorImpl<char> &Out, SmallVectorImpl<Directive> &Directives,
+      : Out(Out), Directives(Directives), Input(Input), Diags(Diags),
         InputSourceLoc(InputSourceLoc) {}
 
-  /// Lex the provided source and emit the minimized output.
+  /// Lex the provided source and emit the directive tokens.
   ///
   /// \returns True on error.
-  bool minimize();
+  bool scan();
 
 private:
   struct IdInfo {
     const char *Last;
     StringRef Name;
   };
 
   /// Lex an identifier.
   ///
   /// \pre First points at a valid identifier head.
   LLVM_NODISCARD IdInfo lexIdentifier(const char *First, const char *const End);
   LLVM_NODISCARD bool isNextIdentifier(StringRef Id, const char *&First,
                                        const char *const End);
-  LLVM_NODISCARD bool minimizeImpl(const char *First, const char *const End);
+  LLVM_NODISCARD bool scanImpl(const char *First, const char *const End);
   LLVM_NODISCARD bool lexPPLine(const char *&First, const char *const End);
   LLVM_NODISCARD bool lexAt(const char *&First, const char *const End);
   LLVM_NODISCARD bool lexModule(const char *&First, const char *const End);
   LLVM_NODISCARD bool lexDefine(const char *&First, const char *const End);
   LLVM_NODISCARD bool lexPragma(const char *&First, const char *const End);
   LLVM_NODISCARD bool lexEndif(const char *&First, const char *const End);
-  LLVM_NODISCARD bool lexDefault(TokenKind Kind, StringRef Directive,
+  LLVM_NODISCARD bool lexDefault(DirectiveKind Kind, StringRef Directive,
                                  const char *&First, const char *const End);
-  Token &makeToken(TokenKind K) {
-    Tokens.emplace_back(K, Out.size());
-    return Tokens.back();
+  Directive &pushDirective(DirectiveKind K) {
+    Directives.emplace_back(K, Out.size());
+    return Directives.back();
   }
-  void popToken() {
-    Out.resize(Tokens.back().Offset);
-    Tokens.pop_back();
+  void popDirective() {
+    Out.resize(Directives.back().Offset);
+    Directives.pop_back();
+  }
+  DirectiveKind topDirective() const {
+    return Directives.empty() ? pp_none : Directives.back().Kind;
   }
-  TokenKind top() const { return Tokens.empty() ? pp_none : Tokens.back().K; }
 
-  Minimizer &put(char Byte) {
+  Scanner &put(char Byte) {
     Out.push_back(Byte);
     return *this;
   }
-  Minimizer &append(StringRef S) { return append(S.begin(), S.end()); }
-  Minimizer &append(const char *First, const char *Last) {
+  Scanner &append(StringRef S) { return append(S.begin(), S.end()); }
+  Scanner &append(const char *First, const char *Last) {
     Out.append(First, Last);
     return *this;
   }
 
   void printToNewline(const char *&First, const char *const End);
   void printAdjacentModuleNameParts(const char *&First, const char *const End);
   LLVM_NODISCARD bool printAtImportBody(const char *&First,
                                         const char *const End);
   void printDirectiveBody(const char *&First, const char *const End);
   void printAdjacentMacroArgs(const char *&First, const char *const End);
   LLVM_NODISCARD bool printMacroArgs(const char *&First, const char *const End);
 
   /// Reports a diagnostic if the diagnostic engine is provided. Always returns
   /// true at the end.
   bool reportError(const char *CurPtr, unsigned Err);
 
   StringMap<char> SplitIds;
   StringRef Input;
   DiagnosticsEngine *Diags;
   SourceLocation InputSourceLoc;
 };
 
 } // end anonymous namespace
 
-bool Minimizer::reportError(const char *CurPtr, unsigned Err) {
+bool Scanner::reportError(const char *CurPtr, unsigned Err) {
   if (!Diags)
     return true;
   assert(CurPtr >= Input.data() && "invalid buffer ptr");
   Diags->Report(InputSourceLoc.getLocWithOffset(CurPtr - Input.data()), Err);
   return true;
 }
 
 static void skipOverSpaces(const char *&First, const char *const End) {
static const char *findLastNonSpaceNonBackslash(const char *First,
                                                 const char *Last) {
   assert(First <= Last);
   while (First != Last &&
          (isHorizontalWhitespace(Last[-1]) || Last[-1] == '\\'))
     --Last;
   return Last;
 }
 
-static const char *findFirstTrailingSpace(const char *First,
-                                          const char *Last) {
+static const char *findFirstTrailingSpace(const char *First, const char *Last) {
   const char *LastNonSpace = findLastNonSpace(First, Last);
   if (Last == LastNonSpace)
     return Last;
   assert(isHorizontalWhitespace(LastNonSpace[0]));
   return LastNonSpace + 1;
 }
 
 static void skipLineComment(const char *&First, const char *const End) {
if (llvm::StringSwitch<bool>(Name)
           .Case("error", true)
           .Default(false))
     // Do not process quotes or comments.
     skipToNewlineRaw(First, End);
   else
     skipLine(First, End);
 }
 
-void Minimizer::printToNewline(const char *&First, const char *const End) {
+void Scanner::printToNewline(const char *&First, const char *const End) {
   while (First != End && !isVerticalWhitespace(*First)) {
     const char *Last = First;
     do {
       // Iterate over strings correctly to avoid comments and newlines.
       if (*Last == '"' || *Last == '\'' ||
-          (*Last == '<' && (top() == pp_include || top() == pp_import))) {
+          (*Last == '<' &&
+           (topDirective() == pp_include || topDirective() == pp_import))) {
         if (LLVM_UNLIKELY(isRawStringLiteral(First, Last)))
           skipRawString(Last, End);
         else
           skipString(Last, End);
         continue;
       }
       if (*Last != '/' || End - Last < 2) {
         ++Last;
for (;;) {
     if (First[1] != '*')
       return;
 
     // "/*...*/".
     skipBlockComment(First, End);
   }
 }
 
-void Minimizer::printAdjacentModuleNameParts(const char *&First,
-                                             const char *const End) {
+void Scanner::printAdjacentModuleNameParts(const char *&First,
   // Skip over parts of the body.
   const char *Last = First;
   do
     ++Last;
   while (Last != End && (isAsciiIdentifierContinue(*Last) || *Last == '.'));
   append(First, Last);
   First = Last;
 }
 
-bool Minimizer::printAtImportBody(const char *&First, const char *const End) {
+bool Scanner::printAtImportBody(const char *&First, const char *const End) {
   for (;;) {
     skipWhitespace(First, End);
     if (First == End)
       return true;
 
     if (isVerticalWhitespace(*First)) {
       skipNewline(First, End);
       continue;
     }
 
     // Found a semicolon.
     if (*First == ';') {
       put(*First++).put('\n');
       return false;
     }
 
     // Don't handle macro expansions inside @import for now.
     if (!isAsciiIdentifierContinue(*First) && *First != '.')
       return true;
 
     printAdjacentModuleNameParts(First, End);
   }
 }
 
-void Minimizer::printDirectiveBody(const char *&First, const char *const End) {
+void Scanner::printDirectiveBody(const char *&First, const char *const End) {
   skipWhitespace(First, End); // Skip initial whitespace.
   printToNewline(First, End);
   while (Out.back() == ' ')
     Out.pop_back();
   put('\n');
 }
 
 LLVM_NODISCARD static const char *lexRawIdentifier(const char *First,
getIdentifierContinuation(const char *First, const char *const End) {
 
   ++First;
   skipNewline(First, End);
   if (First == End)
     return nullptr;
   return isAsciiIdentifierContinue(First[0]) ? First : nullptr;
 }
 
-Minimizer::IdInfo Minimizer::lexIdentifier(const char *First,
-                                           const char *const End) {
+Scanner::IdInfo Scanner::lexIdentifier(const char *First,
   const char *Last = lexRawIdentifier(First, End);
   const char *Next = getIdentifierContinuation(Last, End);
   if (LLVM_LIKELY(!Next))
     return IdInfo{Last, StringRef(First, Last - First)};
 
   // Slow path, where identifiers are split over lines.
   SmallVector<char, 64> Id(First, Last);
   while (Next) {
     Last = lexRawIdentifier(Next, End);
     Id.append(Next, Last);
     Next = getIdentifierContinuation(Last, End);
   }
   return IdInfo{
       Last,
       SplitIds.try_emplace(StringRef(Id.begin(), Id.size()), 0).first->first()};
 }
 
-void Minimizer::printAdjacentMacroArgs(const char *&First,
-                                       const char *const End) {
+void Scanner::printAdjacentMacroArgs(const char *&First,
   // Skip over parts of the body.
   const char *Last = First;
   do
     ++Last;
   while (Last != End &&
          (isAsciiIdentifierContinue(*Last) || *Last == '.' || *Last == ','));
   append(First, Last);
   First = Last;
 }
 
-bool Minimizer::printMacroArgs(const char *&First, const char *const End) {
+bool Scanner::printMacroArgs(const char *&First, const char *const End) {
   assert(*First == '(');
   put(*First++);
   for (;;) {
     skipWhitespace(First, End);
     if (First == End)
       return true;
 
     if (*First == ')') {
       put(*First++);
       return false;
     }
 
     // This is intentionally fairly liberal.
     if (!(isAsciiIdentifierContinue(*First) || *First == '.' || *First == ','))
       return true;
 
     printAdjacentMacroArgs(First, End);
   }
 }
 
 /// Looks for an identifier starting from Last.
 ///
 /// Updates "First" to just past the next identifier, if any.  Returns true iff
 /// the identifier matches "Id".
-bool Minimizer::isNextIdentifier(StringRef Id, const char *&First,
-                                 const char *const End) {
+bool Scanner::isNextIdentifier(StringRef Id, const char *&First,
   skipWhitespace(First, End);
   if (First == End || !isAsciiIdentifierStart(*First))
     return false;
 
   IdInfo FoundId = lexIdentifier(First, End);
   First = FoundId.Last;
   return FoundId.Name == Id;
 }
 
-bool Minimizer::lexAt(const char *&First, const char *const End) {
+bool Scanner::lexAt(const char *&First, const char *const End) {
   // Handle "@import".
   const char *ImportLoc = First++;
   if (!isNextIdentifier("import", First, End)) {
     skipLine(First, End);
     return false;
   }
-  makeToken(decl_at_import);
+  pushDirective(decl_at_import);
   append("@import ");
   if (printAtImportBody(First, End))
     return reportError(
-        ImportLoc, diag::err_dep_source_minimizer_missing_sema_after_at_import);
+        ImportLoc, diag::err_dep_source_scanner_missing_semi_after_at_import);
   skipWhitespace(First, End);
   if (First == End)
     return false;
   if (!isVerticalWhitespace(*First))
     return reportError(
-        ImportLoc, diag::err_dep_source_minimizer_unexpected_tokens_at_import);
+        ImportLoc, diag::err_dep_source_scanner_unexpected_tokens_at_import);
   skipNewline(First, End);
   return false;
 }
 
-bool Minimizer::lexModule(const char *&First, const char *const End) {
+bool Scanner::lexModule(const char *&First, const char *const End) {
   IdInfo Id = lexIdentifier(First, End);
   First = Id.Last;
   bool Export = false;
   if (Id.Name == "export") {
     Export = true;
     skipWhitespace(First, End);
     if (!isAsciiIdentifierContinue(*First)) {
       skipLine(First, End);
bool Scanner::lexModule(const char *&First, const char *const End) {
   default:
     if (!isAsciiIdentifierContinue(*First)) {
       skipLine(First, End);
       return false;
     }
   }
 
   if (Export) {
-    makeToken(cxx_export_decl);
+    pushDirective(cxx_export_decl);
     append("export ");
   }
 
   if (Id.Name == "module")
-    makeToken(cxx_module_decl);
+    pushDirective(cxx_module_decl);
   else
-    makeToken(cxx_import_decl);
+    pushDirective(cxx_import_decl);
   append(Id.Name);
   append(" ");
   printToNewline(First, End);
   append("\n");
   return false;
 }
 
-bool Minimizer::lexDefine(const char *&First, const char *const End) {
-  makeToken(pp_define);
+bool Scanner::lexDefine(const char *&First, const char *const End) {
+  pushDirective(pp_define);
   append("#define ");
   skipWhitespace(First, End);
 
   if (!isAsciiIdentifierStart(*First))
     return reportError(First, diag::err_pp_macro_not_identifier);
 
   IdInfo Id = lexIdentifier(First, End);
   const char *Last = Id.Last;
if (Last == End)
     return false;
   if (!isVerticalWhitespace(*Last))
     put(' ');
   printDirectiveBody(Last, End);
   First = Last;
   return false;
 }
 
-bool Minimizer::lexPragma(const char *&First, const char *const End) {
+bool Scanner::lexPragma(const char *&First, const char *const End) {
   // #pragma.
   skipWhitespace(First, End);
   if (First == End || !isAsciiIdentifierStart(*First))
     return false;
 
   IdInfo FoundId = lexIdentifier(First, End);
   First = FoundId.Last;
   if (FoundId.Name == "once") {
     // #pragma once
     skipLine(First, End);
-    makeToken(pp_pragma_once);
+    pushDirective(pp_pragma_once);
     append("#pragma once\n");
     return false;
   }
   if (FoundId.Name == "push_macro") {
     // #pragma push_macro
-    makeToken(pp_pragma_push_macro);
+    pushDirective(pp_pragma_push_macro);
     append("#pragma push_macro");
     printDirectiveBody(First, End);
     return false;
   }
   if (FoundId.Name == "pop_macro") {
     // #pragma pop_macro
-    makeToken(pp_pragma_pop_macro);
+    pushDirective(pp_pragma_pop_macro);
     append("#pragma pop_macro");
     printDirectiveBody(First, End);
     return false;
   }
   if (FoundId.Name == "include_alias") {
     // #pragma include_alias
-    makeToken(pp_pragma_include_alias);
+    pushDirective(pp_pragma_include_alias);
     append("#pragma include_alias");
     printDirectiveBody(First, End);
     return false;
   }
 
   if (FoundId.Name != "clang") {
     skipLine(First, End);
     return false;
   }
 
   // #pragma clang.
   if (!isNextIdentifier("module", First, End)) {
     skipLine(First, End);
     return false;
   }
 
   // #pragma clang module.
   if (!isNextIdentifier("import", First, End)) {
     skipLine(First, End);
     return false;
   }
 
   // #pragma clang module import.
-  makeToken(pp_pragma_import);
+  pushDirective(pp_pragma_import);
   append("#pragma clang module import ");
   printDirectiveBody(First, End);
   return false;
 }
 
-bool Minimizer::lexEndif(const char *&First, const char *const End) {
+bool Scanner::lexEndif(const char *&First, const char *const End) {
   // Strip out "#else" if it's empty.
-  if (top() == pp_else)
-    popToken();
+  if (topDirective() == pp_else)
+    popDirective();
 
   // If "#ifdef" is empty, strip it and skip the "#endif".
   //
   // FIXME: Once/if Clang starts disallowing __has_include in macro expansions,
   // we can skip empty `#if` and `#elif` blocks as well after scanning for a
   // literal __has_include in the condition.  Even without that rule we could
   // drop the tokens if we scan for identifiers in the condition and find none.
-  if (top() == pp_ifdef || top() == pp_ifndef) {
-    popToken();
+  if (topDirective() == pp_ifdef || topDirective() == pp_ifndef) {
+    popDirective();
     skipLine(First, End);
     return false;
   }
 
   return lexDefault(pp_endif, "endif", First, End);
 }
 
-bool Minimizer::lexDefault(TokenKind Kind, StringRef Directive,
-                           const char *&First, const char *const End) {
-  makeToken(Kind);
+bool Scanner::lexDefault(DirectiveKind Kind, StringRef Directive,
+  pushDirective(Kind);
   put('#').append(Directive).put(' ');
   printDirectiveBody(First, End);
   return false;
 }
 
 static bool isStartOfRelevantLine(char First) {
   switch (First) {
   case '#':
   case '@':
   case 'i':
   case 'e':
   case 'm':
     return true;
   }
   return false;
 }
 
-bool Minimizer::lexPPLine(const char *&First, const char *const End) {
+bool Scanner::lexPPLine(const char *&First, const char *const End) {
   assert(First != End);
 
   skipWhitespace(First, End);
   assert(First <= End);
   if (First == End)
     return false;
 
   if (!isStartOfRelevantLine(*First)) {
bool Scanner::lexPPLine(const char *&First, const char *const End) {
 
   // Figure out the token.
   IdInfo Id = lexIdentifier(First, End);
   First = Id.Last;
 
   if (Id.Name == "pragma")
     return lexPragma(First, End);
 
-  auto Kind = llvm::StringSwitch<TokenKind>(Id.Name)
+  auto Kind = llvm::StringSwitch<DirectiveKind>(Id.Name)
                   .Case("include", pp_include)
                   .Case("__include_macros", pp___include_macros)
                   .Case("define", pp_define)
                   .Case("undef", pp_undef)
                   .Case("import", pp_import)
                   .Case("include_next", pp_include_next)
                   .Case("if", pp_if)
                   .Case("ifdef", pp_ifdef)

 }
 
 static void skipUTF8ByteOrderMark(const char *&First, const char *const End) {
   if ((End - First) >= 3 && First[0] == '\xef' && First[1] == '\xbb' &&
       First[2] == '\xbf')
     First += 3;
 }
 
-bool Minimizer::minimizeImpl(const char *First, const char *const End) {
+bool Scanner::scanImpl(const char *First, const char *const End) {
   skipUTF8ByteOrderMark(First, End);
   while (First != End)
     if (lexPPLine(First, End))
       return true;
   return false;
 }
 
-bool Minimizer::minimize() {
-  bool Error = minimizeImpl(Input.begin(), Input.end());
+bool Scanner::scan() {
+  bool Error = scanImpl(Input.begin(), Input.end());
 
   if (!Error) {
     // Add a trailing newline and an EOF on success.
     if (!Out.empty() && Out.back() != '\n')
       Out.push_back('\n');
-    makeToken(pp_eof);
+    pushDirective(pp_eof);
   }
 
   // Null-terminate the output. This way the memory buffer that's passed to
   // Clang will not have to worry about the terminating '\0'.
   Out.push_back(0);
   Out.pop_back();
   return Error;
 }
 
-bool clang::minimize_source_to_dependency_directives::computeSkippedRanges(
-    ArrayRef<Token> Input, llvm::SmallVectorImpl<SkippedRange> &Range) {
-  struct Directive {
+bool clang::dependency_directives_scan::computeSkippedRanges(
+    ArrayRef<Directive> Input, llvm::SmallVectorImpl<SkippedRange> &Range) {
+  struct IfElseDirective {
     enum DirectiveKind {
       If,  // if/ifdef/ifndef
       Else // elif/elifdef/elifndef, else
     };
     int Offset;
     DirectiveKind Kind;
   };
-  llvm::SmallVector<Directive, 32> Offsets;
-  for (const Token &T : Input) {
-    switch (T.K) {
+  llvm::SmallVector<IfElseDirective, 32> Offsets;
+  for (const Directive &T : Input) {
+    switch (T.Kind) {
     case pp_if:
     case pp_ifdef:
     case pp_ifndef:
-      Offsets.push_back({T.Offset, Directive::If});
+      Offsets.push_back({T.Offset, IfElseDirective::If});
       break;
 
     case pp_elif:
     case pp_elifdef:
     case pp_elifndef:
     case pp_else: {
       if (Offsets.empty())
         return true;
       int PreviousOffset = Offsets.back().Offset;
       Range.push_back({PreviousOffset, T.Offset - PreviousOffset});
-      Offsets.push_back({T.Offset, Directive::Else});
+      Offsets.push_back({T.Offset, IfElseDirective::Else});
       break;
     }
 
     case pp_endif: {
       if (Offsets.empty())
         return true;
       int PreviousOffset = Offsets.back().Offset;
       Range.push_back({PreviousOffset, T.Offset - PreviousOffset});
       do {
-        Directive::DirectiveKind Kind = Offsets.pop_back_val().Kind;
-        if (Kind == Directive::If)
+        IfElseDirective::DirectiveKind Kind = Offsets.pop_back_val().Kind;
+        if (Kind == IfElseDirective::If)
           break;
       } while (!Offsets.empty());
       break;
     }
     default:
       break;
     }
   }
   return false;
 }
 
-bool clang::minimizeSourceToDependencyDirectives(
+bool clang::scanSourceForDependencyDirectives(
     StringRef Input, SmallVectorImpl<char> &Output,
-    SmallVectorImpl<Token> &Tokens, DiagnosticsEngine *Diags,
+    SmallVectorImpl<Directive> &Directives, DiagnosticsEngine *Diags,
     SourceLocation InputSourceLoc) {
   Output.clear();
-  Tokens.clear();
-  return Minimizer(Output, Tokens, Input, Diags, InputSourceLoc).minimize();
+  Directives.clear();
+  return Scanner(Output, Directives, Input, Diags, InputSourceLoc).scan();
 }

clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp

 //===- DependencyScanningFilesystem.cpp - clang-scan-deps fs --------------===//
 //
 // 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/DependencyScanningFilesystem.h"
-#include "clang/Lex/DependencyDirectivesSourceMinimizer.h"
+#include "clang/Lex/DependencyDirectivesScanner.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SmallVectorMemoryBuffer.h"
 #include "llvm/Support/Threading.h"
 
 using namespace clang;
 using namespace tooling;
 using namespace dependencies;
 
DependencyScanningWorkerFilesystem::readFile(StringRef Filename) {
 
   // If the file size changed between read and stat, pretend it didn't.
   if (Stat.getSize() != Buffer->getBufferSize())
     Stat = llvm::vfs::Status::copyWithNewSize(Stat, Buffer->getBufferSize());
 
   return TentativeEntry(Stat, std::move(Buffer));
 }
 
-EntryRef DependencyScanningWorkerFilesystem::minimizeIfNecessary(
+EntryRef DependencyScanningWorkerFilesystem::scanForDirectivesIfNecessary(
     const CachedFileSystemEntry &Entry, StringRef Filename, bool Disable) {
   if (Entry.isError() || Entry.isDirectory() || Disable ||
-      !shouldMinimize(Filename, Entry.getUniqueID()))
+      !shouldScanForDirectives(Filename, Entry.getUniqueID()))
     return EntryRef(/*Minimized=*/false, Filename, Entry);
 
-  CachedFileContents *Contents = Entry.getContents();
+  CachedFileContents *Contents = Entry.getCachedContents();
   assert(Contents && "contents not initialized");
 
   // Double-checked locking.
   if (Contents->MinimizedAccess.load())
     return EntryRef(/*Minimized=*/true, Filename, Entry);
 
   std::lock_guard<std::mutex> GuardLock(Contents->ValueLock);
 
   // Double-checked locking.
   if (Contents->MinimizedAccess.load())
     return EntryRef(/*Minimized=*/true, Filename, Entry);
 
   llvm::SmallString<1024> MinimizedFileContents;
   // Minimize the file down to directives that might affect the dependencies.
-  SmallVector<minimize_source_to_dependency_directives::Token, 64> Tokens;
-  if (minimizeSourceToDependencyDirectives(Contents->Original->getBuffer(),
-                                           MinimizedFileContents, Tokens)) {
+  SmallVector<dependency_directives_scan::Directive, 64> Tokens;
+  if (scanSourceForDependencyDirectives(Contents->Original->getBuffer(),
     // FIXME: Propagate the diagnostic if desired by the client.
     // Use the original file if the minimization failed.
     Contents->MinimizedStorage =
         llvm::MemoryBuffer::getMemBuffer(*Contents->Original);
     Contents->MinimizedAccess.store(Contents->MinimizedStorage.get());
     return EntryRef(/*Minimized=*/true, Filename, Entry);
   }
 
   // The contents produced by the minimizer must be null terminated.
   assert(MinimizedFileContents.data()[MinimizedFileContents.size()] == '\0' &&
          "not null terminated contents");
 
   // Compute the skipped PP ranges that speedup skipping over inactive
   // preprocessor blocks.
-  llvm::SmallVector<minimize_source_to_dependency_directives::SkippedRange, 32>
-      SkippedRanges;
-  minimize_source_to_dependency_directives::computeSkippedRanges(Tokens,
-                                                                 SkippedRanges);
+  llvm::SmallVector<dependency_directives_scan::SkippedRange, 32> SkippedRanges;
+  dependency_directives_scan::computeSkippedRanges(Tokens, SkippedRanges);
   PreprocessorSkippedRangeMapping Mapping;
   for (const auto &Range : SkippedRanges) {
     if (Range.Length < 16) {
       // Ignore small ranges as non-profitable.
       // FIXME: This is a heuristic, its worth investigating the tradeoffs
       // when it should be applied.
       continue;
     }
DependencyScanningFilesystemSharedCache::CacheShard::
   return *EntriesByFilename.insert({Filename, &Entry}).first->getValue();
 }
 
 /// Whitelist file extensions that should be minimized, treating no extension as
 /// a source file that should be minimized.
 ///
 /// This is kinda hacky, it would be better if we knew what kind of file Clang
 /// was expecting instead.
-static bool shouldMinimizeBasedOnExtension(StringRef Filename) {
+static bool shouldScanForDirectivesBasedOnExtension(StringRef Filename) {
   StringRef Ext = llvm::sys::path::extension(Filename);
   if (Ext.empty())
     return true; // C++ standard library
   return llvm::StringSwitch<bool>(Ext)
       .CasesLower(".c", ".cc", ".cpp", ".c++", ".cxx", true)
       .CasesLower(".h", ".hh", ".hpp", ".h++", ".hxx", true)
       .CasesLower(".m", ".mm", true)
       .CasesLower(".i", ".ii", ".mi", ".mmi", true)
       .CasesLower(".def", ".inc", true)
       .Default(false);
 }
 
 static bool shouldCacheStatFailures(StringRef Filename) {
   StringRef Ext = llvm::sys::path::extension(Filename);
   if (Ext.empty())
     return false; // This may be the module cache directory.
   // Only cache stat failures on source files.
-  return shouldMinimizeBasedOnExtension(Filename);
+  return shouldScanForDirectivesBasedOnExtension(Filename);
 }
 
-void DependencyScanningWorkerFilesystem::disableMinimization(
+void DependencyScanningWorkerFilesystem::disableDirectivesScanning(
     StringRef Filename) {
-  // Since we're not done setting up `NotToBeMinimized` yet, we need to disable
-  // minimization explicitly.
-  if (llvm::ErrorOr<EntryRef> Result =
-          getOrCreateFileSystemEntry(Filename, /*DisableMinimization=*/true))
-    NotToBeMinimized.insert(Result->getStatus().getUniqueID());
+  // Since we're not done setting up `NotToBeScanned` yet, we need to disable
+  // directive scanning explicitly.
+  if (llvm::ErrorOr<EntryRef> Result = getOrCreateFileSystemEntry(
+          Filename, /*DisableDirectivesScanning=*/true))
+    NotToBeScanned.insert(Result->getStatus().getUniqueID());
 }
 
-bool DependencyScanningWorkerFilesystem::shouldMinimize(
+bool DependencyScanningWorkerFilesystem::shouldScanForDirectives(
     StringRef Filename, llvm::sys::fs::UniqueID UID) {
-  return shouldMinimizeBasedOnExtension(Filename) &&
-         !NotToBeMinimized.contains(UID);
+  return shouldScanForDirectivesBasedOnExtension(Filename) &&
+         !NotToBeScanned.contains(UID);
 }
 
 const CachedFileSystemEntry &
 DependencyScanningWorkerFilesystem::getOrEmplaceSharedEntryForUID(
     TentativeEntry TEntry) {
   auto &Shard = SharedCache.getShardForUID(TEntry.Status.getUniqueID());
   return Shard.getOrEmplaceEntryForUID(TEntry.Status.getUniqueID(),
                                        std::move(TEntry.Status),
const CachedFileSystemEntry *SharedEntry = [&]() {
     return &getOrEmplaceSharedEntryForFilename(Filename, TEntry.getError());
   }();
 
   return insertLocalEntryForFilename(Filename, *SharedEntry);
 }
 
 llvm::ErrorOr<EntryRef>
 DependencyScanningWorkerFilesystem::getOrCreateFileSystemEntry(
-    StringRef Filename, bool DisableMinimization) {
+    StringRef Filename, bool DisableDirectivesScanning) {
   if (const auto *Entry = findEntryByFilenameWithWriteThrough(Filename))
-    return minimizeIfNecessary(*Entry, Filename, DisableMinimization)
+    return scanForDirectivesIfNecessary(*Entry, Filename,
+                                        DisableDirectivesScanning)
         .unwrapError();
   auto MaybeEntry = computeAndStoreResult(Filename);
   if (!MaybeEntry)
     return MaybeEntry.getError();
-  return minimizeIfNecessary(*MaybeEntry, Filename, DisableMinimization)
+  return scanForDirectivesIfNecessary(*MaybeEntry, Filename,
+                                      DisableDirectivesScanning)
       .unwrapError();
 }
 
 llvm::ErrorOr<llvm::vfs::Status>
 DependencyScanningWorkerFilesystem::status(const Twine &Path) {
   SmallString<256> OwnedFilename;
   StringRef Filename = Path.toStringRef(OwnedFilename);
 
   llvm::ErrorOr<EntryRef> Result = getOrCreateFileSystemEntry(Filename);
   if (!Result)
     return Result.getError();
   return Result->getStatus();
 }
 
 namespace {
 
 /// The VFS that is used by clang consumes the \c CachedFileSystemEntry using
 /// this subclass.
-class MinimizedVFSFile final : public llvm::vfs::File {
+class DepScanFile final : public llvm::vfs::File {
 public:
-  MinimizedVFSFile(std::unique_ptr<llvm::MemoryBuffer> Buffer,
-                   llvm::vfs::Status Stat)
+  DepScanFile(std::unique_ptr<llvm::MemoryBuffer> Buffer,
       : Buffer(std::move(Buffer)), Stat(std::move(Stat)) {}
 
   static llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>>
   create(EntryRef Entry,
          ExcludedPreprocessorDirectiveSkipMapping &PPSkipMappings);
 
   llvm::ErrorOr<llvm::vfs::Status> status() override { return Stat; }
 
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
   getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator,
             bool IsVolatile) override {
     return std::move(Buffer);
   }
 
   std::error_code close() override { return {}; }
 
 private:
   std::unique_ptr<llvm::MemoryBuffer> Buffer;
   llvm::vfs::Status Stat;
 };
 
 } // end anonymous namespace
 
-llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>> MinimizedVFSFile::create(
-    EntryRef Entry, ExcludedPreprocessorDirectiveSkipMapping &PPSkipMappings) {
+llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>>
+DepScanFile::create(EntryRef Entry,
+                    ExcludedPreprocessorDirectiveSkipMapping &PPSkipMappings) {
   assert(!Entry.isError() && "error");
 
   if (Entry.isDirectory())
     return std::make_error_code(std::errc::is_a_directory);
 
-  auto Result = std::make_unique<MinimizedVFSFile>(
+  auto Result = std::make_unique<DepScanFile>(
       llvm::MemoryBuffer::getMemBuffer(Entry.getContents(),
                                        Entry.getStatus().getName(),
                                        /*RequiresNullTerminator=*/false),
       Entry.getStatus());
 
   const auto *EntrySkipMappings = Entry.getPPSkippedRangeMapping();
   if (EntrySkipMappings && !EntrySkipMappings->empty())
     PPSkipMappings[Result->Buffer->getBufferStart()] = EntrySkipMappings;
 
   return llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>>(
       std::unique_ptr<llvm::vfs::File>(std::move(Result)));
 }
 
 llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>>
 DependencyScanningWorkerFilesystem::openFileForRead(const Twine &Path) {
   SmallString<256> OwnedFilename;
   StringRef Filename = Path.toStringRef(OwnedFilename);
 
   llvm::ErrorOr<EntryRef> Result = getOrCreateFileSystemEntry(Filename);
   if (!Result)
     return Result.getError();
-  return MinimizedVFSFile::create(Result.get(), PPSkipMappings);
+  return DepScanFile::create(Result.get(), PPSkipMappings);
 }

clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp

bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation,
     if (!ScanInstance.getPreprocessorOpts().ImplicitPCHInclude.empty())
       visitPrebuiltModule(
           ScanInstance.getPreprocessorOpts().ImplicitPCHInclude, ScanInstance,
           ScanInstance.getHeaderSearchOpts().PrebuiltModuleFiles,
           PrebuiltModulesInputFiles, /*VisitInputFiles=*/DepFS != nullptr);
 
     // Use the dependency scanning optimized file system if requested to do so.
     if (DepFS) {
-      DepFS->enableMinimizationOfAllFiles();
+      DepFS->enableDirectivesScanningOfAllFiles();
       // Don't minimize any files that contributed to prebuilt modules. The
       // implicit build validates the modules by comparing the reported sizes of
       // their inputs to the current state of the filesystem. Minimization would
       // throw this mechanism off.
       for (const auto &File : PrebuiltModulesInputFiles)
-        DepFS->disableMinimization(File.getKey());
+        DepFS->disableDirectivesScanning(File.getKey());
       // Don't minimize any files that were explicitly passed in the build
       // settings and that might be opened.
       for (const auto &E : ScanInstance.getHeaderSearchOpts().UserEntries)
-        DepFS->disableMinimization(E.Path);
+        DepFS->disableDirectivesScanning(E.Path);
       for (const auto &F : ScanInstance.getHeaderSearchOpts().VFSOverlayFiles)
-        DepFS->disableMinimization(F);
+        DepFS->disableDirectivesScanning(F);
 
       // Support for virtual file system overlays on top of the caching
       // filesystem.
       FileMgr->setVirtualFileSystem(createVFSFromCompilerInvocation(
           ScanInstance.getInvocation(), ScanInstance.getDiagnostics(), DepFS));
 
       // Pass the skip mappings which should speed up excluded conditional block
       // skipping in the preprocessor.
PCHContainerOps->registerWriter(
       std::make_unique<ObjectFilePCHContainerWriter>());
 
   auto OverlayFS = llvm::makeIntrusiveRefCnt<llvm::vfs::OverlayFileSystem>(
       llvm::vfs::createPhysicalFileSystem());
   InMemoryFS = llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>();
   OverlayFS->pushOverlay(InMemoryFS);
   RealFS = OverlayFS;
 
-  if (Service.getMode() == ScanningMode::MinimizedSourcePreprocessing)
+  if (Service.getMode() == ScanningMode::DependencyDirectivesScan)
     DepFS = new DependencyScanningWorkerFilesystem(Service.getSharedCache(),
                                                    RealFS, PPSkipMappings);
   if (Service.canReuseFileManager())
     Files = new FileManager(FileSystemOptions(), RealFS);
 }
 
 static llvm::Error
 runWithDiags(DiagnosticOptions *DiagOpts,

clang/test/ClangScanDeps/has_include_if_elif.cpp

 // RUN: rm -rf %t.dir
 // RUN: rm -rf %t.cdb
 // RUN: mkdir -p %t.dir
 // RUN: cp %s %t.dir/has_include_if_elif2.cpp
 // RUN: cp %s %t.dir/has_include_if_elif2_clangcl.cpp
 // RUN: mkdir %t.dir/Inputs
 // RUN: cp %S/Inputs/header.h %t.dir/Inputs/header.h
 // RUN: cp %S/Inputs/header.h %t.dir/Inputs/header2.h
 // RUN: cp %S/Inputs/header.h %t.dir/Inputs/header3.h
 // RUN: cp %S/Inputs/header.h %t.dir/Inputs/header4.h
 // RUN: sed -e "s|DIR|%/t.dir|g" %S/Inputs/has_include_if_elif.json > %t.cdb
 //
-// RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck %s
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -mode preprocess | \
 // RUN:   FileCheck %s
 
 #if __has_include("header.h")
 #endif
 
 #if 0

clang/test/ClangScanDeps/macro-expansions.cpp

+// This checks that there's no issue with the preprocessor handling user or built-in macro
+// expansion during dependency scanning.
+
+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: sed -e "s|DIR|%/t|g" %t/cdb.json.template > %t/cdb.json
+
+// RUN: clang-scan-deps -compilation-database %t/cdb.json | FileCheck %s
+
+// CHECK: test.o:
+// CHECK-NEXT: test.cpp
+// CHECK-NEXT: header1.h
+// CHECK-NEXT: header2.h
+
+//--- cdb.json.template
+[{
+  "directory" : "DIR",
+  "command" : "clang -c DIR/test.cpp -o DIR/test.o",
+  "file" : "DIR/test.o"
+}]
+
+//--- test.cpp
+#define FN_MACRO(x) 1
+#if FN_MACRO(a)
+#include "header1.h"
+#endif
+
+#if __has_cpp_attribute(clang::fallthrough)
+#include "header2.h"
+#endif
+
+//--- header1.h
+#ifndef _HEADER1_H_
+#define _HEADER1_H_
+#endif
+
+//--- header2.h
+#ifndef _HEADER2_H_
+#define _HEADER2_H_
+#endif

clang/test/ClangScanDeps/modulemap-via-vfs.m

 // RUN: rm -rf %t.dir
 // RUN: split-file %s %t.dir
 // RUN: sed -e "s|DIR|%/t.dir|g" %t.dir/build/compile-commands.json.in > %t.dir/build/compile-commands.json
 // RUN: sed -e "s|DIR|%/t.dir|g" %t.dir/build/vfs.yaml.in > %t.dir/build/vfs.yaml
 // RUN: clang-scan-deps -compilation-database %t.dir/build/compile-commands.json -j 1 -format experimental-full \
-// RUN:   -mode preprocess-minimized-sources -generate-modules-path-args > %t.db
+// RUN:   -mode preprocess-dependency-directives -generate-modules-path-args > %t.db
 // RUN: %deps-to-rsp %t.db --module-name=A > %t.A.cc1.rsp
 // RUN: cat %t.A.cc1.rsp | sed 's:\\\\\?:/:g' | FileCheck %s
 
 // CHECK-NOT: build/module.modulemap
 // CHECK: A/module.modulemap
 
 //--- build/compile-commands.json.in
 

clang/test/ClangScanDeps/modules-fmodule-name-no-module-built.m

 // RUN: rm -rf %t.dir
 // RUN: rm -rf %t.cdb
 // RUN: mkdir -p %t.dir
 // RUN: cp %s %t.dir/modules-fmodule-name-no-module-built.m
 // RUN: mkdir %t.dir/Inputs
 // RUN: cp %S/Inputs/header.h %t.dir/Inputs/header.h
 // RUN: cp %S/Inputs/header2.h %t.dir/Inputs/header2.h
 // RUN: cp %S/Inputs/header3.h %t.dir/Inputs/header3.h
 // RUN: cp %S/Inputs/module.modulemap %t.dir/Inputs/module.modulemap
 // RUN: sed -e "s|DIR|%/t.dir|g" %S/Inputs/module_fmodule_name_cdb.json > %t.cdb
 
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -format experimental-full \
-// RUN:   -generate-modules-path-args -mode preprocess-minimized-sources > %t.result
+// RUN:   -generate-modules-path-args -mode preprocess-dependency-directives > %t.result
 // RUN: cat %t.result | sed 's:\\\\\?:/:g' | FileCheck -DPREFIX=%/t.dir --check-prefixes=CHECK %s
 
 #import "header3.h"
 #import "header.h"
 
 // CHECK:      {
 // CHECK-NEXT:   "modules": [
 // CHECK-NEXT:     {

clang/test/ClangScanDeps/modules-full-by-mod-name.cpp

 // UNSUPPORTED: powerpc64-ibm-aix
 // RUN: rm -rf %t.dir
 // RUN: rm -rf %t.cdb
 // RUN: mkdir -p %t.dir
 // RUN: cp %s %t.dir/modules_cdb_input.cpp
 // RUN: cp %s %t.dir/modules_cdb_input2.cpp
 // RUN: mkdir %t.dir/Inputs
 // RUN: cp %S/Inputs/header.h %t.dir/Inputs/header.h
 // RUN: cp %S/Inputs/header2.h %t.dir/Inputs/header2.h
 // RUN: cp %S/Inputs/module.modulemap %t.dir/Inputs/module.modulemap
 // RUN: sed -e "s|DIR|%/t.dir|g" %S/Inputs/modules_cdb_by_mod_name.json > %t.cdb
 // RUN: sed -e "s|DIR|%/t.dir|g" %S/Inputs/modules_cdb_clangcl_by_mod_name.json > %t_clangcl.cdb
 //
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 4 -format experimental-full \
-// RUN:   -mode preprocess-minimized-sources -module-name=header1 > %t.result
+// RUN:   -mode preprocess-dependency-directives -module-name=header1 > %t.result
 // RUN: cat %t.result | sed 's:\\\\\?:/:g' | FileCheck -DPREFIX=%/t.dir --check-prefixes=CHECK %s
 //
 // RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 4 -format experimental-full \
-// RUN:   -mode preprocess-minimized-sources -module-name=header1 > %t_clangcl.result
+// RUN:   -mode preprocess-dependency-directives -module-name=header1 > %t_clangcl.result
 // RUN: cat %t_clangcl.result | sed 's:\\\\\?:/:g' | FileCheck -DPREFIX=%/t.dir --check-prefixes=CHECK %s
 
 // CHECK:      {
 // CHECK-NEXT:   "modules": [
 // CHECK-NEXT:     {
 // CHECK-NEXT:       "clang-module-deps": [
 // CHECK-NEXT:         {
 // CHECK-NEXT:           "context-hash": "[[HASH_H2_DINCLUDE:[A-Z0-9]+]]",

clang/test/ClangScanDeps/modules-full.cpp

 // RUN: rm -rf %t.dir
 // RUN: rm -rf %t.cdb
 // RUN: mkdir -p %t.dir
 // RUN: cp %s %t.dir/modules_cdb_input.cpp
 // RUN: cp %s %t.dir/modules_cdb_input2.cpp
 // RUN: mkdir %t.dir/Inputs
 // RUN: cp %S/Inputs/header.h %t.dir/Inputs/header.h
 // RUN: cp %S/Inputs/header2.h %t.dir/Inputs/header2.h
 // RUN: cp %S/Inputs/module.modulemap %t.dir/Inputs/module.modulemap
 // RUN: sed -e "s|DIR|%/t.dir|g" %S/Inputs/modules_cdb.json > %t.cdb
 // RUN: sed -e "s|DIR|%/t.dir|g" %S/Inputs/modules_cdb_clangcl.json > %t_clangcl.cdb
 //
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 4 -format experimental-full \
-// RUN:   -mode preprocess-minimized-sources > %t.result
+// RUN:   -mode preprocess-dependency-directives > %t.result
 // RUN: cat %t.result | sed 's:\\\\\?:/:g' | FileCheck -DPREFIX=%/t.dir --check-prefixes=CHECK,CHECK-NO-ABS %s
 //
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 4 -format experimental-full \
-// RUN:   -generate-modules-path-args -mode preprocess-minimized-sources > %t.result
+// RUN:   -generate-modules-path-args -mode preprocess-dependency-directives > %t.result
 // RUN: cat %t.result | sed 's:\\\\\?:/:g' | FileCheck -DPREFIX=%/t.dir --check-prefixes=CHECK,CHECK-ABS %s
 //
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 4 -format experimental-full \
 // RUN:   -generate-modules-path-args -module-files-dir %t.dir/custom \
-// RUN:   -mode preprocess-minimized-sources > %t.result
+// RUN:   -mode preprocess-dependency-directives > %t.result
 // RUN: cat %t.result | sed 's:\\\\\?:/:g' | FileCheck -DPREFIX=%/t.dir --check-prefixes=CHECK,CHECK-CUSTOM %s
 //
 // RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 4 -format experimental-full \
-// RUN:   -mode preprocess-minimized-sources > %t_clangcl.result
+// RUN:   -mode preprocess-dependency-directives > %t_clangcl.result
 // RUN: cat %t_clangcl.result | sed 's:\\\\\?:/:g' | FileCheck -DPREFIX=%/t.dir --check-prefixes=CHECK,CHECK-NO-ABS %s
 
 #include "header.h"
 
 // CHECK:      {
 // CHECK-NEXT:   "modules": [
 // CHECK-NEXT:     {
 // CHECK-NEXT:       "clang-module-deps": [

clang/test/ClangScanDeps/modules-inferred-explicit-build.m

 // RUN: rm -rf %t.dir
 // RUN: rm -rf %t.cdb
 // RUN: mkdir -p %t.dir
 // RUN: cp %s %t.dir/modules_cdb_input.cpp
 // RUN: sed -e "s|DIR|%/t.dir|g" -e "s|FRAMEWORKS|%/S/Inputs/frameworks|g" -e "s|-E|-x objective-c -E|g" \
 // RUN:   %S/Inputs/modules_inferred_cdb.json > %t.cdb
 //
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -format experimental-full \
-// RUN:   -mode preprocess-minimized-sources -generate-modules-path-args > %t.db
+// RUN:   -mode preprocess-dependency-directives -generate-modules-path-args > %t.db
 // RUN: %deps-to-rsp %t.db --module-name=Inferred > %t.inferred.cc1.rsp
 // RUN: %deps-to-rsp %t.db --module-name=System > %t.system.cc1.rsp
 // RUN: %deps-to-rsp %t.db --tu-index=0 > %t.tu.rsp
 // RUN: %clang @%t.inferred.cc1.rsp -pedantic -Werror
 // RUN: %clang @%t.system.cc1.rsp -pedantic -Werror
 // RUN: %clang @%t.tu.rsp -pedantic -Werror
 
 #include <Inferred/Inferred.h>
 #include <System/System.h>
 
 inferred a = bigger_than_int;

clang/test/ClangScanDeps/modules-inferred.m

 // RUN: rm -rf %t.dir
 // RUN: rm -rf %t.cdb
 // RUN: mkdir -p %t.dir
 // RUN: cp %s %t.dir/modules_cdb_input.cpp
 // RUN: sed -e "s|DIR|%/t.dir|g" -e "s|FRAMEWORKS|%/S/Inputs/frameworks|g" \
 // RUN:   %/S/Inputs/modules_inferred_cdb.json > %t.cdb
 //
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -format experimental-full \
-// RUN:   -generate-modules-path-args -mode preprocess-minimized-sources > %t.result
+// RUN:   -generate-modules-path-args -mode preprocess-dependency-directives > %t.result
 // RUN: cat %t.result | sed 's:\\\\\?:/:g' | FileCheck %s -DPREFIX=%/t.dir -DSOURCEDIR=%/S --check-prefixes=CHECK
 
 #include <Inferred/Inferred.h>
 
 inferred a = 0;
 
 // CHECK:      {
 // CHECK-NEXT:   "modules": [

clang/test/ClangScanDeps/modules.cpp

 // RUN: rm -rf %t.dir
 // RUN: rm -rf %t.cdb
 // RUN: rm -rf %t_clangcl.cdb
 // RUN: rm -rf %t.module-cache
 // RUN: rm -rf %t.module-cache_clangcl
 // RUN: mkdir -p %t.dir
 // RUN: cp %s %t.dir/modules_cdb_input.cpp
 // RUN: cp %s %t.dir/modules_cdb_input2.cpp
 // RUN: mkdir %t.dir/Inputs
 // RUN: cp %S/Inputs/header.h %t.dir/Inputs/header.h
 // RUN: cp %S/Inputs/header2.h %t.dir/Inputs/header2.h
 // RUN: cp %S/Inputs/module.modulemap %t.dir/Inputs/module.modulemap
 // RUN: sed -e "s|DIR|%/t.dir|g" %S/Inputs/modules_cdb.json > %t.cdb
 // RUN: sed -e "s|DIR|%/t.dir|g" %S/Inputs/modules_cdb_clangcl.json > %t_clangcl.cdb
 //
-// RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck --check-prefixes=CHECK1,CHECK2,CHECK2NO %s
-// RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 1 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 1 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck --check-prefixes=CHECK1,CHECK2,CHECK2NO %s
 //
 // The output order is non-deterministic when using more than one thread,
 // so check the output using two runs. Note that the 'NOT' check is not used
 // as it might fail if the results for `modules_cdb_input.cpp` are reported before
 // `modules_cdb_input2.cpp`.
 //
-// RUN: clang-scan-deps -compilation-database %t.cdb -j 2 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t.cdb -j 2 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck --check-prefix=CHECK1 %s
-// RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 2 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 2 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck --check-prefix=CHECK1 %s
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 2 -mode preprocess | \
 // RUN:   FileCheck --check-prefix=CHECK1 %s
 // RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 2 -mode preprocess | \
 // RUN:   FileCheck --check-prefix=CHECK1 %s
-// RUN: clang-scan-deps -compilation-database %t.cdb -j 2 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t.cdb -j 2 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck --check-prefix=CHECK2 %s
-// RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 2 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 2 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck --check-prefix=CHECK2 %s
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 2 -mode preprocess | \
 // RUN:   FileCheck --check-prefix=CHECK2 %s
 // RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 2 -mode preprocess | \
 // RUN:   FileCheck --check-prefix=CHECK2 %s
 
 #include "header.h"
 

clang/test/ClangScanDeps/preprocess_minimized_pragmas.cpp

 // RUN: rm -rf %t.dir
 // RUN: rm -rf %t.cdb
 // RUN: mkdir -p %t.dir
 // RUN: cp %s %t.dir/preprocess_minimized_pragmas_basic.cpp
 // RUN: cp %s %t.dir/preprocess_minimized_pragmas_ms.cpp
 // RUN: mkdir %t.dir/Inputs
 // RUN: cp %S/Inputs/preprocess_minimized_pragmas.h %t.dir/Inputs/preprocess_minimized_pragmas.h
 // RUN: touch %t.dir/Inputs/a.h
 // RUN: touch %t.dir/Inputs/b.h
 // RUN: touch %t.dir/Inputs/c.h
 // RUN: touch %t.dir/Inputs/c_alias.h
 // RUN: sed -e "s|DIR|%/t.dir|g" %S/Inputs/preprocess_minimized_pragmas_cdb.json > %t.cdb
 //
-// RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck %s
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -mode preprocess | \
 // RUN:   FileCheck %s
 
 #include "preprocess_minimized_pragmas.h"
 
 // CHECK: preprocess_minimized_pragmas_basic.cpp
 // CHECK-NEXT: Inputs{{/|\\}}preprocess_minimized_pragmas.h

clang/test/ClangScanDeps/regular_cdb.cpp

 // RUN: rm -rf %t.dir
 // RUN: rm -rf %t.cdb
 // RUN: rm -rf %t_clangcl.cdb
 // RUN: mkdir -p %t.dir
 // RUN: cp %s %t.dir/regular_cdb_input.cpp
 // RUN: cp %s %t.dir/regular_cdb_input2.cpp
 // RUN: mkdir %t.dir/Inputs
 // RUN: cp %S/Inputs/header.h %t.dir/Inputs/header.h
 // RUN: cp %S/Inputs/header2.h %t.dir/Inputs/header2.h
 // RUN: sed -e "s|DIR|%/t.dir|g" %S/Inputs/regular_cdb.json > %t.cdb
 // RUN: sed -e "s|DIR|%/t.dir|g" %S/Inputs/regular_cdb_clangcl.json > %t_clangcl.cdb
 //
-// RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck --check-prefixes=CHECK1,CHECK2,CHECK2NO,CHECK3 %s
-// RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 1 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 1 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck --check-prefixes=CHECK1,CHECK2,CHECK2NO,CHECK3 %s
 
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 1 -mode preprocess | \
 // RUN:   FileCheck --check-prefixes=CHECK1,CHECK2,CHECK2NO,CHECK3 %s
 // RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 1 -mode preprocess | \
 // RUN:   FileCheck --check-prefixes=CHECK1,CHECK2,CHECK2NO,CHECK3 %s
 
 // Make sure we didn't produce any dependency files!
 // RUN: not cat %t.dir/regular_cdb.d
 // RUN: not cat %t.dir/regular_cdb_clangcl.d
 // RUN: not cat %t.dir/regular_cdb2.d
 // RUN: not cat %t.dir/regular_cdb2_clangcl.d
 //
 // The output order is non-deterministic when using more than one thread,
 // so check the output using two runs. Note that the 'NOT' check is not used
 // as it might fail if the results for `regular_cdb_input.cpp` are reported before
 // `regular_cdb_input2.cpp`.
 //
-// RUN: clang-scan-deps -compilation-database %t.cdb -j 2 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t.cdb -j 2 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck --check-prefix=CHECK1 %s
-// RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 2 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 2 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck --check-prefix=CHECK1 %s
 
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 2 -mode preprocess | \
 // RUN:   FileCheck --check-prefix=CHECK1 %s
 // RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 2 -mode preprocess | \
 // RUN:   FileCheck --check-prefix=CHECK1 %s
 
-// RUN: clang-scan-deps -compilation-database %t.cdb -j 2 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t.cdb -j 2 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck --check-prefix=CHECK2 %s
-// RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 2 -mode preprocess-minimized-sources | \
+// RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 2 -mode preprocess-dependency-directives | \
 // RUN:   FileCheck --check-prefix=CHECK2 %s
 
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 2 -mode preprocess | \
 // RUN:   FileCheck --check-prefix=CHECK2 %s
 // RUN: clang-scan-deps -compilation-database %t_clangcl.cdb -j 2 -mode preprocess | \
 // RUN:   FileCheck --check-prefix=CHECK2 %s
 
 #include "header.h"

clang/tools/clang-scan-deps/ClangScanDeps.cpp

llvm::cl::opt<bool> Help("h", llvm::cl::desc("Alias for -help"),
                          llvm::cl::Hidden);
 
 llvm::cl::OptionCategory DependencyScannerCategory("Tool options");
 
 static llvm::cl::opt<ScanningMode> ScanMode(
     "mode",
     llvm::cl::desc("The preprocessing mode used to compute the dependencies"),
     llvm::cl::values(
-        clEnumValN(ScanningMode::MinimizedSourcePreprocessing,
-                   "preprocess-minimized-sources",
-                   "The set of dependencies is computed by preprocessing the "
-                   "source files that were minimized to only include the "
-                   "contents that might affect the dependencies"),
+        clEnumValN(ScanningMode::DependencyDirectivesScan,
+                   "preprocess-dependency-directives",
+                   "The set of dependencies is computed by preprocessing with "
+                   "special lexing after scanning the source files to get the "
+                   "directives that might affect the dependencies"),
         clEnumValN(ScanningMode::CanonicalPreprocessing, "preprocess",
                    "The set of dependencies is computed by preprocessing the "
-                   "unmodified source files")),
-    llvm::cl::init(ScanningMode::MinimizedSourcePreprocessing),
+                   "source files")),
+    llvm::cl::init(ScanningMode::DependencyDirectivesScan),
     llvm::cl::cat(DependencyScannerCategory));
 
 static llvm::cl::opt<ScanningOutputFormat> Format(
     "format", llvm::cl::desc("The output format for the dependencies"),
     llvm::cl::values(clEnumValN(ScanningOutputFormat::Make, "make",
                                 "Makefile compatible dep file"),
                      clEnumValN(ScanningOutputFormat::Full, "experimental-full",
                                 "Full dependency graph suitable"

clang/unittests/Lex/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(LexTests
-  DependencyDirectivesSourceMinimizerTest.cpp
+  DependencyDirectivesScannerTest.cpp
   HeaderMapTest.cpp
   HeaderSearchTest.cpp
   LexerTest.cpp
   PPCallbacksTest.cpp
   PPConditionalDirectiveRecordTest.cpp
   PPMemoryAllocationsTest.cpp
   )
 
 clang_target_link_libraries(LexTests
   PRIVATE
   clangAST
   clangBasic
   clangLex
   clangParse
   clangSema
   )

clang/unittests/Lex/DependencyDirectivesScannerTest.cpp

-//===- unittests/Lex/DependencyDirectivesSourceMinimizer.cpp -  -----------===//
+//===- unittests/Lex/DependencyDirectivesScannerTest.cpp ------------------===//
 //
 // 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/Lex/DependencyDirectivesSourceMinimizer.h"
+#include "clang/Lex/DependencyDirectivesScanner.h"
 #include "llvm/ADT/SmallString.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace clang;
-using namespace clang::minimize_source_to_dependency_directives;
+using namespace clang::dependency_directives_scan;
 
-namespace clang {
-
-bool minimizeSourceToDependencyDirectives(StringRef Input,
+static bool minimizeSourceToDependencyDirectives(StringRef Input,
                                                  SmallVectorImpl<char> &Out) {
-  SmallVector<minimize_source_to_dependency_directives::Token, 32> Tokens;
-  return minimizeSourceToDependencyDirectives(Input, Out, Tokens);
+  SmallVector<dependency_directives_scan::Directive, 32> Directives;
+  return scanSourceForDependencyDirectives(Input, Out, Directives);
 }
 
-} // end namespace clang
+static bool
+minimizeSourceToDependencyDirectives(StringRef Input,
+                                     SmallVectorImpl<char> &Out,
+                                     SmallVectorImpl<Directive> &Directives) {
+  return scanSourceForDependencyDirectives(Input, Out, Directives);
+}
 
 namespace {
 
 TEST(MinimizeSourceToDependencyDirectivesTest, Empty) {
   SmallVector<char, 128> Out;
-  SmallVector<Token, 4> Tokens;
+  SmallVector<Directive, 4> Directives;
 
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives("", Out, Tokens));
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives("", Out, Directives));
   EXPECT_TRUE(Out.empty());
-  ASSERT_EQ(1u, Tokens.size());
-  ASSERT_EQ(pp_eof, Tokens.back().K);
+  ASSERT_EQ(1u, Directives.size());
+  ASSERT_EQ(pp_eof, Directives.back().Kind);
 
   ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("abc def\nxyz", Out, Tokens));
+      minimizeSourceToDependencyDirectives("abc def\nxyz", Out, Directives));
   EXPECT_TRUE(Out.empty());
-  ASSERT_EQ(1u, Tokens.size());
-  ASSERT_EQ(pp_eof, Tokens.back().K);
+  ASSERT_EQ(1u, Directives.size());
+  ASSERT_EQ(pp_eof, Directives.back().Kind);
 }
 
-TEST(MinimizeSourceToDependencyDirectivesTest, AllTokens) {
+TEST(MinimizeSourceToDependencyDirectivesTest, AllDirectives) {
   SmallVector<char, 128> Out;
-  SmallVector<Token, 4> Tokens;
+  SmallVector<Directive, 4> Directives;
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define A\n"
                                            "#undef A\n"
                                            "#endif\n"
                                            "#if A\n"
                                            "#ifdef A\n"
                                            "#ifndef A\n"
                                            "#elifdef A\n"
                                            "#elifndef A\n"
                                            "#elif A\n"
                                            "#else\n"
                                            "#include <A>\n"
                                            "#include_next <A>\n"
                                            "#__include_macros <A>\n"
                                            "#import <A>\n"
                                            "@import A;\n"
                                            "#pragma clang module import A\n"
                                            "#pragma push_macro(A)\n"
                                            "#pragma pop_macro(A)\n"
                                            "#pragma include_alias(<A>, <B>)\n"
                                            "export module m;\n"
                                            "import m;\n",
-                                           Out, Tokens));
-  EXPECT_EQ(pp_define, Tokens[0].K);
-  EXPECT_EQ(pp_undef, Tokens[1].K);
-  EXPECT_EQ(pp_endif, Tokens[2].K);
-  EXPECT_EQ(pp_if, Tokens[3].K);
-  EXPECT_EQ(pp_ifdef, Tokens[4].K);
-  EXPECT_EQ(pp_ifndef, Tokens[5].K);
-  EXPECT_EQ(pp_elifdef, Tokens[6].K);
-  EXPECT_EQ(pp_elifndef, Tokens[7].K);
-  EXPECT_EQ(pp_elif, Tokens[8].K);
-  EXPECT_EQ(pp_else, Tokens[9].K);
-  EXPECT_EQ(pp_include, Tokens[10].K);
-  EXPECT_EQ(pp_include_next, Tokens[11].K);
-  EXPECT_EQ(pp___include_macros, Tokens[12].K);
-  EXPECT_EQ(pp_import, Tokens[13].K);
-  EXPECT_EQ(decl_at_import, Tokens[14].K);
-  EXPECT_EQ(pp_pragma_import, Tokens[15].K);
-  EXPECT_EQ(pp_pragma_push_macro, Tokens[16].K);
-  EXPECT_EQ(pp_pragma_pop_macro, Tokens[17].K);
-  EXPECT_EQ(pp_pragma_include_alias, Tokens[18].K);
-  EXPECT_EQ(cxx_export_decl, Tokens[19].K);
-  EXPECT_EQ(cxx_module_decl, Tokens[20].K);
-  EXPECT_EQ(cxx_import_decl, Tokens[21].K);
-  EXPECT_EQ(pp_eof, Tokens[22].K);
+                                           Out, Directives));
+  EXPECT_EQ(pp_define, Directives[0].Kind);
+  EXPECT_EQ(pp_undef, Directives[1].Kind);
+  EXPECT_EQ(pp_endif, Directives[2].Kind);
+  EXPECT_EQ(pp_if, Directives[3].Kind);
+  EXPECT_EQ(pp_ifdef, Directives[4].Kind);
+  EXPECT_EQ(pp_ifndef, Directives[5].Kind);
+  EXPECT_EQ(pp_elifdef, Directives[6].Kind);
+  EXPECT_EQ(pp_elifndef, Directives[7].Kind);
+  EXPECT_EQ(pp_elif, Directives[8].Kind);
+  EXPECT_EQ(pp_else, Directives[9].Kind);
+  EXPECT_EQ(pp_include, Directives[10].Kind);
+  EXPECT_EQ(pp_include_next, Directives[11].Kind);
+  EXPECT_EQ(pp___include_macros, Directives[12].Kind);
+  EXPECT_EQ(pp_import, Directives[13].Kind);
+  EXPECT_EQ(decl_at_import, Directives[14].Kind);
+  EXPECT_EQ(pp_pragma_import, Directives[15].Kind);
+  EXPECT_EQ(pp_pragma_push_macro, Directives[16].Kind);
+  EXPECT_EQ(pp_pragma_pop_macro, Directives[17].Kind);
+  EXPECT_EQ(pp_pragma_include_alias, Directives[18].Kind);
+  EXPECT_EQ(cxx_export_decl, Directives[19].Kind);
+  EXPECT_EQ(cxx_module_decl, Directives[20].Kind);
+  EXPECT_EQ(cxx_import_decl, Directives[21].Kind);
+  EXPECT_EQ(pp_eof, Directives[22].Kind);
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, Define) {
   SmallVector<char, 128> Out;
-  SmallVector<Token, 4> Tokens;
+  SmallVector<Directive, 4> Directives;
 
   ASSERT_FALSE(
-      minimizeSourceToDependencyDirectives("#define MACRO", Out, Tokens));
+      minimizeSourceToDependencyDirectives("#define MACRO", Out, Directives));
   EXPECT_STREQ("#define MACRO\n", Out.data());
-  ASSERT_EQ(2u, Tokens.size());
-  ASSERT_EQ(pp_define, Tokens.front().K);
+  ASSERT_EQ(2u, Directives.size());
+  ASSERT_EQ(pp_define, Directives.front().Kind);
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, DefineSpacing) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO\n\n\n", Out));
   EXPECT_STREQ("#define MACRO\n", Out.data());

 // '
 )";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#include <test.h>\n", Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, PragmaOnce) {
   SmallVector<char, 128> Out;
-  SmallVector<Token, 4> Tokens;
+  SmallVector<Directive, 4> Directives;
 
   StringRef Source = R"(// comment
 #pragma once
 // another comment
 #include <test.h>
 )";
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Tokens));
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Directives));
   EXPECT_STREQ("#pragma once\n#include <test.h>\n", Out.data());
-  ASSERT_EQ(Tokens.size(), 3u);
-  EXPECT_EQ(Tokens[0].K,
-            minimize_source_to_dependency_directives::pp_pragma_once);
+  ASSERT_EQ(Directives.size(), 3u);
+  EXPECT_EQ(Directives[0].Kind, dependency_directives_scan::pp_pragma_once);
 
   Source = R"(// comment
     #pragma once extra tokens
     // another comment
     #include <test.h>
     )";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#pragma once\n#include <test.h>\n", Out.data());
TEST(MinimizeSourceToDependencyDirectivesTest,
 
   Source = "#define X \"\\ \r\nx\n#include <x>\n";
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
   EXPECT_STREQ("#define X \"\\ \r\nx\n#include <x>\n", Out.data());
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, CxxModules) {
   SmallVector<char, 128> Out;
-  SmallVector<Token, 4> Tokens;
+  SmallVector<Directive, 4> Directives;
 
   StringRef Source = R"(
     module;
     #include "textual-header.h"
 
     export module m;
     exp\
 ort \
void h() {
 
       import a b d e d e f e;
       import foo [[no_unique_address]];
       import foo();
       import f(:sefse);
       import f(->a = 3);
     }
     )";
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Tokens));
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Directives));
   EXPECT_STREQ("#include \"textual-header.h\"\nexport module m;\n"
                "export import :l [[rename]];\n"
                "import <<= 3;\nimport a b d e d e f e;\n"
                "import foo [[no_unique_address]];\nimport foo();\n"
-               "import f(:sefse);\nimport f(->a = 3);\n", Out.data());
-  ASSERT_EQ(Tokens.size(), 12u);
-  EXPECT_EQ(Tokens[0].K,
-            minimize_source_to_dependency_directives::pp_include);
-  EXPECT_EQ(Tokens[2].K,
-            minimize_source_to_dependency_directives::cxx_module_decl);
+               "import f(:sefse);\nimport f(->a = 3);\n",
+               Out.data());
+  ASSERT_EQ(Directives.size(), 12u);
+  EXPECT_EQ(Directives[0].Kind, dependency_directives_scan::pp_include);
+  EXPECT_EQ(Directives[2].Kind, dependency_directives_scan::cxx_module_decl);
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, SkippedPPRangesBasic) {
   SmallString<128> Out;
-  SmallVector<Token, 32> Toks;
+  SmallVector<Directive, 32> Directives;
   StringRef Source = "#ifndef GUARD\n"
                      "#define GUARD\n"
                      "void foo();\n"
                      "#endif\n";
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Toks));
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Directives));
   SmallVector<SkippedRange, 4> Ranges;
-  ASSERT_FALSE(computeSkippedRanges(Toks, Ranges));
+  ASSERT_FALSE(computeSkippedRanges(Directives, Ranges));
   EXPECT_EQ(Ranges.size(), 1u);
   EXPECT_EQ(Ranges[0].Offset, 0);
   EXPECT_EQ(Ranges[0].Length, (int)Out.find("#endif"));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, SkippedPPRangesBasicElifdef) {
   SmallString<128> Out;
-  SmallVector<Token, 32> Toks;
+  SmallVector<Directive, 32> Directives;
   StringRef Source = "#ifdef BLAH\n"
                      "void skip();\n"
                      "#elifdef BLAM\n"
                      "void skip();\n"
                      "#elifndef GUARD\n"
                      "#define GUARD\n"
                      "void foo();\n"
                      "#endif\n";
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Toks));
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Directives));
   SmallVector<SkippedRange, 4> Ranges;
-  ASSERT_FALSE(computeSkippedRanges(Toks, Ranges));
+  ASSERT_FALSE(computeSkippedRanges(Directives, Ranges));
   EXPECT_EQ(Ranges.size(), 3u);
   EXPECT_EQ(Ranges[0].Offset, 0);
   EXPECT_EQ(Ranges[0].Length, (int)Out.find("#elifdef"));
   EXPECT_EQ(Ranges[1].Offset, (int)Out.find("#elifdef"));
   EXPECT_EQ(Ranges[1].Offset + Ranges[1].Length, (int)Out.find("#elifndef"));
   EXPECT_EQ(Ranges[2].Offset, (int)Out.find("#elifndef"));
   EXPECT_EQ(Ranges[2].Offset + Ranges[2].Length, (int)Out.rfind("#endif"));
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, SkippedPPRangesNested) {
   SmallString<128> Out;
-  SmallVector<Token, 32> Toks;
+  SmallVector<Directive, 32> Directives;
   StringRef Source = "#ifndef GUARD\n"
                      "#define GUARD\n"
                      "#if FOO\n"
                      "#include hello\n"
                      "#elif BAR\n"
                      "#include bye\n"
                      "#endif\n"
                      "#else\n"
                      "#include nothing\n"
                      "#endif\n";
-  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Toks));
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Directives));
   SmallVector<SkippedRange, 4> Ranges;
-  ASSERT_FALSE(computeSkippedRanges(Toks, Ranges));
+  ASSERT_FALSE(computeSkippedRanges(Directives, Ranges));
   EXPECT_EQ(Ranges.size(), 4u);
   EXPECT_EQ(Ranges[0].Offset, (int)Out.find("#if FOO"));
   EXPECT_EQ(Ranges[0].Offset + Ranges[0].Length, (int)Out.find("#elif"));
   EXPECT_EQ(Ranges[1].Offset, (int)Out.find("#elif BAR"));
   EXPECT_EQ(Ranges[1].Offset + Ranges[1].Length, (int)Out.find("#endif"));
   EXPECT_EQ(Ranges[2].Offset, 0);
   EXPECT_EQ(Ranges[2].Length, (int)Out.find("#else"));
   EXPECT_EQ(Ranges[3].Offset, (int)Out.find("#else"));
   EXPECT_EQ(Ranges[3].Offset + Ranges[3].Length, (int)Out.rfind("#endif"));
 }
 
 } // end anonymous namespace

clang/unittests/Tooling/DependencyScannerTest.cpp

TEST(DependencyScanningFilesystem, IgnoredFilesAreCachedSeparately1) {
   VFS->addFile("/mod.h", 0,
                llvm::MemoryBuffer::getMemBuffer("#include <foo.h>\n"
                                                 "// hi there!\n"));
 
   DependencyScanningFilesystemSharedCache SharedCache;
   ExcludedPreprocessorDirectiveSkipMapping Mappings;
   DependencyScanningWorkerFilesystem DepFS(SharedCache, VFS, Mappings);
 
-  DepFS.enableMinimizationOfAllFiles(); // Let's be explicit for clarity.
+  DepFS.enableDirectivesScanningOfAllFiles(); // Let's be explicit for clarity.
   auto StatusMinimized0 = DepFS.status("/mod.h");
-  DepFS.disableMinimization("/mod.h");
+  DepFS.disableDirectivesScanning("/mod.h");
   auto StatusFull1 = DepFS.status("/mod.h");
 
   EXPECT_TRUE(StatusMinimized0);
   EXPECT_TRUE(StatusFull1);
   EXPECT_EQ(StatusMinimized0->getSize(), 17u);
   EXPECT_EQ(StatusFull1->getSize(), 30u);
   EXPECT_EQ(StatusMinimized0->getName(), StringRef("/mod.h"));
   EXPECT_EQ(StatusFull1->getName(), StringRef("/mod.h"));
 }
 
 TEST(DependencyScanningFilesystem, IgnoredFilesAreCachedSeparately2) {
   auto VFS = llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>();
   VFS->addFile("/mod.h", 0,
                llvm::MemoryBuffer::getMemBuffer("#include <foo.h>\n"
                                                 "// hi there!\n"));
 
   DependencyScanningFilesystemSharedCache SharedCache;
   ExcludedPreprocessorDirectiveSkipMapping Mappings;
   DependencyScanningWorkerFilesystem DepFS(SharedCache, VFS, Mappings);
 
-  DepFS.disableMinimization("/mod.h");
+  DepFS.disableDirectivesScanning("/mod.h");
   auto StatusFull0 = DepFS.status("/mod.h");
-  DepFS.enableMinimizationOfAllFiles();
+  DepFS.enableDirectivesScanningOfAllFiles();
   auto StatusMinimized1 = DepFS.status("/mod.h");
 
   EXPECT_TRUE(StatusFull0);
   EXPECT_TRUE(StatusMinimized1);
   EXPECT_EQ(StatusFull0->getSize(), 30u);
   EXPECT_EQ(StatusMinimized1->getSize(), 17u);
   EXPECT_EQ(StatusFull0->getName(), StringRef("/mod.h"));
   EXPECT_EQ(StatusMinimized1->getName(), StringRef("/mod.h"));
 }
 
 } // end namespace dependencies
 } // end namespace tooling
 } // end namespace clang