[clang][lex] Fix search path usage remark with modules

[jansvoboda11]

Summary

When looking for module, HeaderSearch::lookupModule iterates through search paths, parses modulemaps, eagerly creates Module instances and caches them in ModuleMap. When first called, it will correctly note usage of the search path that discovered the returned module. On subsequent calls, however, it can pull previously created Module from ModuleMap without noting the search path was used.

This patch fixes that. This requires HeaderSearch to be able to go from Module to the index of corresponding search path. This is achieved by adding a callback to the modulemap parser, intercepting creations of Module instances and pairing them with the current search path index.

The outlined solution doesn't handle all corner cases, though. It's possible for clients to use HeaderSearch to lookup module B, which could parse an unrelated modulemap and create instance of module A. The client can then look up module A directly in ModuleMap, avoiding the logic in HeaderSearch that makes -Rsearch-path-usage work.

Depends on D116750 & D116751.

[jansvoboda11]

clang/lib/Lex/HeaderSearch.cpp

264

This is the important change.

[jansvoboda11]

Apply clang-format.

[jansvoboda11]

Add extra test case

[ahoppen]

LGTM overall. I’ve got a few questions/remarks inline.

clang/lib/Lex/HeaderSearch.cpp

94

When would the moduleMapModuleCreated be called while CurrentSearchPathIdx == ~0U? Could this be an assert instead?

264

Just a thought: Could we move noteModuleLookupUsage into findModule? IIUC that would guarantee that we’re catching all cases and we wouldn’t need to call noteModuleLookupUsage from both overloads of lookupModule.

clang/lib/Lex/ModuleMap.cpp

851

Maybe a stupid question but why don’t we need to call the callback e.g. here (or on the other new Module) calls in this file?

[jansvoboda11]

Thanks for the feedback, I'll try to clean this up a bit.

clang/lib/Lex/HeaderSearch.cpp

94

This happens whenever any of the ModuleMap member functions that create new Module instances are called outside of HeaderSearch.

The MMCallback callback is basically "global" (present for the whole lifetime of ModuleMap), so that we don't have to repeatedly register/deregister it in HeaderSearch::lookupModule.

264

That would clean up HeaderSearch nicely. I'll look into creating new HeaderSearch::findModule function that would wrap ModuleMap::findModule and note usage.

clang/lib/Lex/ModuleMap.cpp

851

This is related to C++20 modules, so it wasn't necessary for the test case I had in mind.

But I agree we should handle this as well. I think more robust solution would be to add factory function to ModuleMap through which all Module instances get created, and invoke the callback there.

[ahoppen]

clang/lib/Lex/HeaderSearch.cpp

94

Is there any reasonable case where module maps would be created without HeaderSearch triggering the creation?

[jansvoboda11]

clang/lib/Lex/HeaderSearch.cpp

94

I think parsing of module maps (and therefore creation of contained modules) should be triggered through HeaderSearch.

However, there are also C++20 modules and explicit Clang modules that are not discovered by the header search mechanisms or modulemap parsing.

[ahoppen]

clang/lib/Lex/HeaderSearch.cpp

95

These indices will be out of date if the search paths are changed via HeaderSearch::SetSearchPaths or HeaderSearch::AddSearchPath after the first module map has been loaded. One could probably adjust the indices in AddSearchPath but maybe it’s easier to not use the index into SearchDirs as the key. An alternative suggestion would be to use std::shared_ptr<DirectoryLookup> instead, changing some of the data structures as follows:

- std::vector<DirectoryLookup> SearchDirs
+ std::vector<std::shared_ptr<DirectoryLookup>> SearchDirs

- std::vector<bool> SearchDirsUsage;
+ std::map<std::shared_ptr<DirectoryLookup>, bool> SearchDirsUsage; 

- llvm::DenseMap<Module *, unsigned> ModuleToSearchDirIdx;
+ llvm::DenseMap<Module *, std::shared_ptr<DirectoryLookup>> ModuleToSearchDirIdx;

- llvm::DenseMap<unsigned, unsigned> SearchDirToHSEntry;
+ llvm::DenseMap<std::shared_ptr<DirectoryLookup>, unsigned> SearchDirToHSEntry;

[jansvoboda11]

Still a WIP, but might be get some feedback on the direction.

I'm not 100% sure when to consider a search path that triggered the creation of Module as used. Doing so on Module creation is not useful, since we do that (somewhat) eagerly. The current approach marks search path as used whenever it's responsible for the creation of a Module that gets returned by HeaderSearch::lookupModule. That's not correct in situations when a Module is created via header search (but not actually returned) and then gets queried directly from ModuleMap instead of HeaderSearch.

[Bigcheese]

Can we not consider a modulemap used when we load an AST that depends on that modulemap? It's possible this breaks if the module only includes textual headers though. It really feels like we should have a single place where we actually know if a module is used or not. Long term I would really like to separate modulemap parsing from Module creation, which would be a great place to actually do this.

For now we just need to make sure we report every modulemap search path that wouldn't change semantics if removed.

[jansvoboda11]

In D113676#3168219, @Bigcheese wrote:

Can we not consider a modulemap used when we load an AST that depends on that modulemap? It's possible this breaks if the module only includes textual headers though.

I don't think that would be 100% correct. I think it's possible for Module instances (created by parsing a modulemap file) to have semantic meaning even without their AST being loaded. One example (that I just made up but sounds plausible enough to me) is that we could have a fixit for an @import of non-existent module that suggests importing another available module (discovered through header search) with the most similar name. We don't need the AST file for that, but removing search paths could change the diagnostic output.

It really feels like we should have a single place where we actually know if a module is used or not. Long term I would really like to separate modulemap parsing from Module creation, which would be a great place to actually do this.

Agreed. But I'm afraid that's a big undertaking. Do you have any other ideas on how to detect module usage with the current state of things?

[jansvoboda11]

Rebase on top of extracted patches.

[jansvoboda11]

clang/lib/Lex/HeaderSearch.cpp

95

Fixed in D116750.

[jansvoboda11]

I'm starting to think it could be fine to keep doing things as outlined by this patch: only marking search paths that discovered a module as used when its Module gets returned from HeaderSearch (and ignoring Modules returned ModuleMap). (Or adopt the AST-reading strategy @Bigcheese suggested.)

I think this could work okay for the purposes of dependency scanning.

If the scanning phase fails with an error, the diagnostics will be presented to the user and the actual compile won't be carried out at all - the pruning optimization won't kick in.
Other kinds of diagnostics (that might be discarded/changed by pruning search paths) will be still visible in the build log of the scanning phase - this might be good enough.
And the preprocessor seems to use HeaderSearch when handling include/import directives without touching ModuleMap, which should work.

If we document this properly in computeUserEntryUsage() I think that may be fine. Any thoughts?

[jansvoboda11]

Rebase.

[jansvoboda11]

clang/lib/Lex/HeaderSearch.cpp

264

Looking more into this, ModuleMap::findModule is used in a lot of different places. Since noteModuleLookupUsage takes SourceLocation of the #include, putting it into findModule that doesn't require SourceLocation ATM would be somewhat intrusive change.

I have cleaned up this patch so that noteModuleLookupUsage is called only in single HeaderSearch::lookupModule. I think this is good enough. WDYT?

clang/lib/Lex/ModuleMap.cpp

851

This is fixed in D116751.

[jansvoboda11]

Abandoning this. We don't need to collect usage info from -fimplicit-module-maps because we don't use that feature during explicit builds: D120465. Support for usage collection for modules was removed entirely in D121295.

clang/include/clang/Lex/HeaderSearch.h

class HeaderSearch {
   /// consecutively. Requests for <x> search the current dir first, then each
   /// directory in SearchDirs, starting at AngledDirIdx, consecutively.  If
   /// NoCurDirSearch is true, then the check for the file in the current
   /// directory is suppressed.
   std::vector<DirectoryLookup> SearchDirs;
   /// Whether the DirectoryLookup at the corresponding index in SearchDirs has
   /// been successfully used to lookup a file.
   std::vector<bool> SearchDirsUsage;
+  /// When iterating through `SearchDirs`, the current index.
+  unsigned CurrentSearchPathIdx;
+  /// Mapping from module to the search directory index that discovered its
+  /// module map file.
+  llvm::DenseMap<Module *, unsigned> ModuleToSearchDirIdx;
+
   unsigned AngledDirIdx = 0;
   unsigned SystemDirIdx = 0;
   bool NoCurDirSearch = false;
 
   /// \#include prefixes for which the 'system header' property is
   /// overridden.
   ///
   /// For a \#include "x" or \#include \<x> directive, the last string in this
getFileAndSuggestModule(StringRef FileName, SourceLocation IncludeLoc,
                           const DirectoryEntry *Dir, bool IsSystemHeaderDir,
                           Module *RequestingModule,
                           ModuleMap::KnownHeader *SuggestedModule);
 
   /// Cache the result of a successful lookup at the given include location
   /// using the search path at index `HitIdx`.
   void cacheLookupSuccess(LookupFileCacheInfo &CacheLookup, unsigned HitIdx,
                           SourceLocation IncludeLoc);
+  void noteModuleLookupUsage(Module *M, SourceLocation Loc);
   /// Note that a lookup at the given include location was successful using the
   /// search path at index `HitIdx`.
   void noteLookupUsage(unsigned HitIdx, SourceLocation IncludeLoc);
 
 public:
   /// Retrieve the module map.
   ModuleMap &getModuleMap() { return ModMap; }
 

clang/include/clang/Lex/ModuleMap.h

public:
   virtual void moduleMapAddHeader(StringRef Filename) {}
 
   /// Called when an umbrella header is added during module map parsing.
   ///
   /// \param FileMgr FileManager instance
   /// \param Header The umbrella header to collect.
   virtual void moduleMapAddUmbrellaHeader(FileManager *FileMgr,
                                           const FileEntry *Header) {}
+
+  /// Called when new module is created.
+  ///
+  /// \param M The newly created module.
+  virtual void moduleMapModuleCreated(Module *M) {}
 };
 
 class ModuleMap {
   SourceManager &SourceMgr;
   DiagnosticsEngine &Diags;
   const LangOptions &LangOpts;
   const TargetInfo *Target;
   HeaderSearch &HeaderInfo;

clang/lib/Lex/HeaderSearch.cpp

 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Capacity.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdio>
 #include <cstring>
 #include <string>
 #include <system_error>

 
 ExternalHeaderFileInfoSource::~ExternalHeaderFileInfoSource() = default;
 
 HeaderSearch::HeaderSearch(std::shared_ptr<HeaderSearchOptions> HSOpts,
                            SourceManager &SourceMgr, DiagnosticsEngine &Diags,
                            const LangOptions &LangOpts,
                            const TargetInfo *Target)
     : HSOpts(std::move(HSOpts)), Diags(Diags),
-      FileMgr(SourceMgr.getFileManager()), FrameworkMap(64),
-      ModMap(SourceMgr, Diags, LangOpts, Target, *this) {}
+      FileMgr(SourceMgr.getFileManager()), CurrentSearchPathIdx(~0U),
+      FrameworkMap(64), ModMap(SourceMgr, Diags, LangOpts, Target, *this) {
+  struct MMCallback : ModuleMapCallbacks {
+    HeaderSearch &HS;
+    MMCallback(HeaderSearch &HS) : HS(HS) {}
+    void moduleMapModuleCreated(Module *M) override {
+      // Module map parsing initiated by header search.
+      if (HS.CurrentSearchPathIdx != ~0U)
+        HS.ModuleToSearchDirIdx[M] = HS.CurrentSearchPathIdx;
+    }
+  };
+  ModMap.addModuleMapCallbacks(std::make_unique<MMCallback>(*this));
+}
 
 void HeaderSearch::PrintStats() {
   llvm::errs() << "\n*** HeaderSearch Stats:\n"
                << FileInfo.size() << " files tracked.\n";
   unsigned NumOnceOnlyFiles = 0, MaxNumIncludes = 0, NumSingleIncludedFiles = 0;
   for (unsigned i = 0, e = FileInfo.size(); i != e; ++i) {
     NumOnceOnlyFiles += (FileInfo[i].isPragmaOnce || FileInfo[i].isImport);
     if (MaxNumIncludes < FileInfo[i].NumIncludes)
std::string HeaderSearch::getCachedModuleFileNameImpl(StringRef ModuleName,
   return Result.str().str();
 }
 
 Module *HeaderSearch::lookupModule(StringRef ModuleName,
                                    SourceLocation ImportLoc, bool AllowSearch,
                                    bool AllowExtraModuleMapSearch) {
   // Look in the module map to determine if there is a module by this name.
   Module *Module = ModMap.findModule(ModuleName);
-  if (Module || !AllowSearch || !HSOpts->ImplicitModuleMaps)
+  if (Module || !AllowSearch || !HSOpts->ImplicitModuleMaps) {
+    noteModuleLookupUsage(Module, ImportLoc);
     return Module;
+  }
 
   StringRef SearchName = ModuleName;
   Module = lookupModule(ModuleName, SearchName, ImportLoc,
                         AllowExtraModuleMapSearch);
 
   // The facility for "private modules" -- adjacent, optional module maps named
   // module.private.modulemap that are supposed to define private submodules --
   // may have different flavors of names: FooPrivate, Foo_Private and Foo.Private.
Module = lookupModule(ModuleName, SearchName, ImportLoc,
                           AllowExtraModuleMapSearch);
   return Module;
 }
 
 Module *HeaderSearch::lookupModule(StringRef ModuleName, StringRef SearchName,
                                    SourceLocation ImportLoc,
                                    bool AllowExtraModuleMapSearch) {
   Module *Module = nullptr;
-  unsigned Idx;
 
   // Look through the various header search paths to load any available module
   // maps, searching for a module map that describes this module.
-  for (Idx = 0; Idx != SearchDirs.size(); ++Idx) {
+  for (unsigned Idx = 0; Idx != SearchDirs.size(); ++Idx) {
+    llvm::SaveAndRestore<unsigned> X(CurrentSearchPathIdx, Idx);
+
     if (SearchDirs[Idx].isFramework()) {
       // Search for or infer a module map for a framework. Here we use
       // SearchName rather than ModuleName, to permit finding private modules
       // named FooPrivate in buggy frameworks named Foo.
       SmallString<128> FrameworkDirName;
       FrameworkDirName += SearchDirs[Idx].getFrameworkDir()->getName();
       llvm::sys::path::append(FrameworkDirName, SearchName + ".framework");
       if (auto FrameworkDir = FileMgr.getDirectory(FrameworkDirName)) {
for (unsigned Idx = 0; Idx != SearchDirs.size(); ++Idx) {
 
     // Look again for the module.
     Module = ModMap.findModule(ModuleName);
     if (Module)
       break;
   }
 
   if (Module)
-    noteLookupUsage(Idx, ImportLoc);
+    noteModuleLookupUsage(Module, ImportLoc);
 
   return Module;
 }
 
 //===----------------------------------------------------------------------===//
 // File lookup within a DirectoryLookup scope
 //===----------------------------------------------------------------------===//
 

 }
 
 void HeaderSearch::cacheLookupSuccess(LookupFileCacheInfo &CacheLookup,
                                       unsigned HitIdx, SourceLocation Loc) {
   CacheLookup.HitIdx = HitIdx;
   noteLookupUsage(HitIdx, Loc);
 }
 
+void HeaderSearch::noteModuleLookupUsage(Module *M, SourceLocation Loc) {
+  auto It = ModuleToSearchDirIdx.find(M);
+  if (It != ModuleToSearchDirIdx.end())
+    noteLookupUsage(It->second, Loc);
+}
+
 void HeaderSearch::noteLookupUsage(unsigned HitIdx, SourceLocation Loc) {
   SearchDirsUsage[HitIdx] = true;
 
   auto UserEntryIdxIt = SearchDirToHSEntry.find(HitIdx);
-  if (UserEntryIdxIt != SearchDirToHSEntry.end())
+  // TODO: Avoid emitting duplicates.
+  if (UserEntryIdxIt != SearchDirToHSEntry.end() && Loc.isValid())
     Diags.Report(Loc, diag::remark_pp_search_path_usage)
         << HSOpts->UserEntries[UserEntryIdxIt->second].Path;
 }
 
 void HeaderSearch::setTarget(const TargetInfo &Target) {
   ModMap.setTarget(Target);
 }
 

 }
 
 void HeaderSearch::collectAllModules(SmallVectorImpl<Module *> &Modules) {
   Modules.clear();
 
   if (HSOpts->ImplicitModuleMaps) {
     // Load module maps for each of the header search directories.
     for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
+      llvm::SaveAndRestore<unsigned> X(CurrentSearchPathIdx, Idx);
+
       bool IsSystem = SearchDirs[Idx].isSystemHeaderDirectory();
       if (SearchDirs[Idx].isFramework()) {
         std::error_code EC;
         SmallString<128> DirNative;
         llvm::sys::path::native(SearchDirs[Idx].getFrameworkDir()->getName(),
                                 DirNative);
 
         // Search each of the ".framework" directories to load them as modules.

 }
 
 void HeaderSearch::loadTopLevelSystemModules() {
   if (!HSOpts->ImplicitModuleMaps)
     return;
 
   // Load module maps for each of the header search directories.
   for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
+    llvm::SaveAndRestore<unsigned> X(CurrentSearchPathIdx, Idx);
+
     // We only care about normal header directories.
     if (!SearchDirs[Idx].isNormalDir()) {
       continue;
     }
 
     // Try to load a module map file for the search directory.
     loadModuleMapFile(SearchDirs[Idx].getDir(),
                       SearchDirs[Idx].isSystemHeaderDirectory(),

clang/lib/Lex/ModuleMap.cpp

std::pair<Module *, bool> ModuleMap::findOrCreateModule(StringRef Name,
                                                         bool IsExplicit) {
   // Try to find an existing module with this name.
   if (Module *Sub = lookupModuleQualified(Name, Parent))
     return std::make_pair(Sub, false);
 
   // Create a new module with this name.
   Module *Result = new Module(Name, SourceLocation(), Parent, IsFramework,
                               IsExplicit, NumCreatedModules++);
+  for (const auto &Callback : Callbacks)
+    Callback->moduleMapModuleCreated(Result);
   if (!Parent) {
     if (LangOpts.CurrentModule == Name)
       SourceModule = Result;
     Modules[Name] = Result;
     ModuleScopeIDs[Result] = CurrentModuleScopeID;
   }
   return std::make_pair(Result, true);
 }
 
 Module *ModuleMap::createGlobalModuleFragmentForModuleUnit(SourceLocation Loc) {
   PendingSubmodules.emplace_back(
       new Module("<global>", Loc, nullptr, /*IsFramework*/ false,
                  /*IsExplicit*/ true, NumCreatedModules++));
   PendingSubmodules.back()->Kind = Module::GlobalModuleFragment;
   return PendingSubmodules.back().get();
 }
 
 Module *
 ModuleMap::createPrivateModuleFragmentForInterfaceUnit(Module *Parent,
                                                        SourceLocation Loc) {
   auto *Result =
       new Module("<private>", Loc, Parent, /*IsFramework*/ false,
                  /*IsExplicit*/ true, NumCreatedModules++);
   Result->Kind = Module::PrivateModuleFragment;
   return Result;
 }
 
 Module *ModuleMap::createModuleForInterfaceUnit(SourceLocation Loc,
                                                 StringRef Name,
                                                 Module *GlobalModule) {
   assert(LangOpts.CurrentModule == Name && "module name mismatch");
Module *ModuleMap::inferFrameworkModule(const DirectoryEntry *FrameworkDir,
   // framework to load *everything*. But, it's not clear that this is a good
   // idea.
   if (!UmbrellaHeader)
     return nullptr;
 
   Module *Result = new Module(ModuleName, SourceLocation(), Parent,
                               /*IsFramework=*/true, /*IsExplicit=*/false,
                               NumCreatedModules++);
+  for (const auto &Callback : Callbacks)
+    Callback->moduleMapModuleCreated(Result);
   InferredModuleAllowedBy[Result] = ModuleMapFile;
   Result->IsInferred = true;
   if (!Parent) {
     if (LangOpts.CurrentModule == ModuleName)
       SourceModule = Result;
     Modules[ModuleName] = Result;
     ModuleScopeIDs[Result] = CurrentModuleScopeID;
   }
Module *ModuleMap::createShadowedModule(StringRef Name, bool IsFramework,
                                         Module *ShadowingModule) {
 
   // Create a new module with this name.
   Module *Result =
       new Module(Name, SourceLocation(), /*Parent=*/nullptr, IsFramework,
                  /*IsExplicit=*/false, NumCreatedModules++);
   Result->ShadowingModule = ShadowingModule;
   Result->markUnavailable(/*Unimportable*/true);
+  for (const auto &Callback : Callbacks)
+    Callback->moduleMapModuleCreated(Result);
   ModuleScopeIDs[Result] = CurrentModuleScopeID;
   ShadowModules.push_back(Result);
 
   return Result;
 }
 
 void ModuleMap::setUmbrellaHeader(
     Module *Mod, const FileEntry *UmbrellaHeader, const Twine &NameAsWritten,

clang/lib/Serialization/ASTReader.cpp

ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
   // top-level AST file is a main file, skip this check because there is no
   // usable header search context.
   assert(!F.ModuleName.empty() &&
          "MODULE_NAME should come before MODULE_MAP_FILE");
   if (F.Kind == MK_ImplicitModule && ModuleMgr.begin()->Kind != MK_MainFile) {
     // An implicitly-loaded module file should have its module listed in some
     // module map file that we've already loaded.
     Module *M =
-        PP.getHeaderSearchInfo().lookupModule(F.ModuleName, F.ImportLoc);
+        PP.getHeaderSearchInfo().lookupModule(F.ModuleName, SourceLocation());
     auto &Map = PP.getHeaderSearchInfo().getModuleMap();
     const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
     // Don't emit module relocation error if we have -fno-validate-pch
     if (!bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
               DisableValidationForModuleKind::Module) &&
         !ModMap) {
       if (!canRecoverFromOutOfDate(F.FileName, ClientLoadCapabilities)) {
         if (auto ASTFE = M ? M->getASTFile() : None) {

clang/test/Preprocessor/search-path-usage-modules.m

+// RUN: rm -rf %t
+// RUN: split-file %s %t
+
+// RUN: %clang_cc1 -Eonly %t/test-both.m   -I %t/sp1 -I %t/sp2 -Rsearch-path-usage \
+// RUN:   -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache 2>&1 | FileCheck %t/test-both.m
+// RUN: %clang_cc1 -Eonly %t/test-first.m  -I %t/sp2 -I %t/sp1 -Rsearch-path-usage \
+// RUN:   -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache 2>&1 | FileCheck %t/test-first.m
+// RUN: %clang_cc1 -Eonly %t/test-second.m -I %t/sp2 -I %t/sp1 -Rsearch-path-usage \
+// RUN:   -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache 2>&1 | FileCheck %t/test-second.m
+
+//--- sp1/module.modulemap
+module mod1 { header "mod1.h" }
+//--- sp1/mod1.h
+int module1();
+
+//--- sp2/module.modulemap
+module mod2 { header "mod2.h" }
+//--- sp2/mod2.h
+int module2();
+
+//--- test-both.m
+@import mod1;
+@import mod2;
+// CHECK: search path used: '{{.*}}/sp1'
+// CHECK: search path used: '{{.*}}/sp2'
+
+//--- test-first.m
+@import mod1;
+// CHECK-NOT: search path used: '{{.*}}/sp2'
+// CHECK:     search path used: '{{.*}}/sp1'
+// CHECK-NOT: search path used: '{{.*}}/sp2'
+
+//--- test-second.m
+@import mod2;
+// CHECK-NOT: search path used: '{{.*}}/sp1'
+// CHECK:     search path used: '{{.*}}/sp2'
+// CHECK-NOT: search path used: '{{.*}}/sp1'

clang/test/Preprocessor/search-path-usage.m

 // RUN:   -I %t/b-missing.hmap                   \
 // RUN:   -I b                                   \
 // RUN:   -DHMAP_MATCHED_BUT_MISSING_IN_HAS_INCLUDE -verify
 #ifdef HMAP_MATCHED_BUT_MISSING_IN_HAS_INCLUDE
 #if __has_include("b.h") // \
 // expected-remark-re {{search path used: '{{.*}}/b-missing.hmap'}}
 #endif
 #endif
-
-// Check that search paths with module maps are reported.
-//
-// RUN: mkdir %t/modulemap_abs
-// RUN: sed "s|DIR|%/S/Inputs/search-path-usage|g"                            \
-// RUN:   %S/Inputs/search-path-usage/modulemap_abs/module.modulemap.template \
-// RUN:     > %t/modulemap_abs/module.modulemap
-// RUN: %clang_cc1 -Eonly %s -Rsearch-path-usage                           \
-// RUN:   -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/modules \
-// RUN:   -I %t/modulemap_abs                                              \
-// RUN:   -I %S/Inputs/search-path-usage/a                                 \
-// RUN:   -DMODMAP_ABS -verify
-#ifdef MODMAP_ABS
-@import b; // \
-// expected-remark-re {{search path used: '{{.*}}/modulemap_abs'}}
-#endif