[clang-tools-extra] [clangd] Resolve out-of-tree module units via ProjectModules (PR #242615)
Atharva Potdar via cfe-commits
cfe-commits at lists.llvm.org
Sat Nov 14 01:00:01 PST 2026
https://github.com/atharva-potdar created https://github.com/llvm/llvm-project/pull/242615
When building C++23/26 projects that use `import std;` with CMake and Ninja, `compile_commands.json` includes an entry for the standard library module unit outside the project tree (e.g., `/usr/share/libc++/v1/std.cppm`).
When `clangd` opens a translation unit in the workspace, `GlobalCompilationDatabase::getProjectModules()` finds the project's CDB by walking parent directories and creates a `ProjectModules` instance using it. `ProjectModules::getSourceForModuleName()` resolves `std` to `/usr/share/libc++/v1/std.cppm`, but `ModulesBuilder` then queries `GlobalCompilationDatabase::getCompileCommand()` and `getProjectInfo()` using that module unit path.
Without `--compile-commands-dir`, `DirectoryBasedGlobalCompilationDatabase` walks the ancestors of `/usr/share/libc++/v1/std.cppm`, finds no CDB, and fails with:
> `Failed to build module std; due to No compile command for /usr/share/libc++/v1/std.cppm`
Similarly, `getProjectInfo()` on the system path returns `std::nullopt` instead of the consuming project's root, causing the module cache to fall back to the user cache directory instead of the project-local `.cache/clangd/modules`.
### Solution
Fall back to the `ProjectModules` CDB and the consuming translation unit's project root when resolving out-of-tree module units:
- Add `ProjectModules::getCompileCommand(PathRef)` to query the project's underlying CDB (applying `CommandMangler` if set).
- In `ModulesBuilder`, fall back to `MDB.getCompileCommand()` when `getCDB().getCompileCommand()` returns `std::nullopt`.
- Fall back to `CDB.getProjectInfo(RequiredSource)` when resolving the module cache root and GC target for out-of-tree module units.
- Guard `Mangler` in `OverlayCDB::getProjectModules()` with `if (Mangler)` to avoid invoking an empty `llvm::unique_function`.
---
### Reproduction & Verification
Minimal CMake project (`CMakeLists.txt` + `main.cpp`):
```cmake
cmake_minimum_required(VERSION 3.31)
project(std_module_test LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 26)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
set(CMAKE_CXX_MODULE_STD 1)
add_executable(app main.cpp)
```
```cpp
import std;
int main() { std::println("Hello, modules!"); }
```
**Before (unpatched `clangd`, without running a prior `cmake --build`):**
```bash
rm -rf build .cache ~/.cache/clangd/modules
cmake -B build -G Ninja \
-DCMAKE_CXX_COMPILER=clang++ \
-DCMAKE_CXX_FLAGS="-stdlib=libc++"
clangd --experimental-modules-support --log=verbose --check=$PWD/main.cpp 2>&1 \
| grep -iE "No compile command|Built module|error|All checks"
```
```text
E[...] Failed to build module std; due to No compile command for /usr/share/libc++/v1/std.cppm
I[...] All checks completed, 1 errors
```
**After (with this patch):**
```bash
rm -rf build .cache ~/.cache/clangd/modules
cmake -B build -G Ninja \
-DCMAKE_CXX_COMPILER=$LLVM_BUILD/bin/clang++ \
-DCMAKE_CXX_FLAGS="-stdlib=libc++"
$LLVM_BUILD/bin/clangd --experimental-modules-support --log=verbose --check=$PWD/main.cpp 2>&1 \
| grep -iE "No compile command|Built module|error|All checks"
```
```text
I[...] Built module std to .../testimport/.cache/clangd/modules/std.cppm-.../std-....pcm
I[...] All checks completed, 0 errors
```
**To build and test:**
```bash
cmake -S llvm -B build -G Ninja \
-DCMAKE_BUILD_TYPE=Release \
-DCMAKE_EXPORT_COMPILE_COMMANDS=OFF \
-DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra" \
-DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi;libunwind" \
-DLLVM_TARGETS_TO_BUILD="X86" \
-DLLVM_ENABLE_LLD=ON
ninja -C build clang clang-scan-deps clangd runtimes ClangdTests
cmake --install build/runtimes/runtimes-bins --component cxx-modules --prefix build
./build/tools/clang/tools/extra/clangd/unittests/ClangdTests \
--gtest_filter="*OverlayCDBTest.GetProjectModulesWithoutMangler*:*PrerequisiteModulesTests.OutOfTreeModuleUnit*"
```
> **Note on testing directly from an LLVM build tree:** Because `--prefix build` installs `std.cppm` inside `$LLVM_BUILD/share/libc++/v1/std.cppm`, if `$LLVM_BUILD/compile_commands.json` is present on disk, `DirectoryBasedGlobalCompilationDatabase` will walk up from `std.cppm`, find LLVM's own CDB, and heuristically interpolate an LLVM C++17 compile command instead of returning `std::nullopt`. Building with `-DCMAKE_EXPORT_COMPILE_COMMANDS=OFF` (or moving `$LLVM_BUILD/compile_commands.json` aside while testing uninstalled `clang++`) avoids this; normal installed toolchains are unaffected.
>From fad5a9bf2c25d85e45b91fc6fe2f5431c052e0a6 Mon Sep 17 00:00:00 2001
From: atharva-potdar <atharvapotdar07 at gmail.com>
Date: Sat, 14 Nov 2026 10:21:40 +0530
Subject: [PATCH] [clangd] Resolve out-of-tree module units via ProjectModules
When building C++23/26 projects that use `import std;` with CMake and Ninja,
compile_commands.json includes an entry for the standard library module unit
outside the project tree (e.g., /usr/share/libc++/v1/std.cppm).
When clangd opens a translation unit in the workspace,
GlobalCompilationDatabase::getProjectModules() finds the project's CDB by
walking parent directories and creates a ProjectModules instance using it.
ProjectModules::getSourceForModuleName() resolves `std` to
/usr/share/libc++/v1/std.cppm, but ModulesBuilder then queries
GlobalCompilationDatabase::getCompileCommand() and getProjectInfo() using
that module unit path.
Without --compile-commands-dir, DirectoryBasedGlobalCompilationDatabase walks
the ancestors of /usr/share/libc++/v1/std.cppm, finds no CDB, and fails with
"No compile command for /usr/share/libc++/v1/std.cppm". Similarly,
getProjectInfo() on the system path returns std::nullopt instead of the
consuming project's root.
Fall back to the ProjectModules CDB and the consuming file's project root:
- Add ProjectModules::getCompileCommand(PathRef) to query the project's
underlying CDB (applying CommandMangler if set).
- In ModulesBuilder, fall back to MDB.getCompileCommand() when
getCDB().getCompileCommand() returns std::nullopt.
- Fall back to CDB.getProjectInfo(RequiredSource) when resolving the
module cache root and GC target for out-of-tree module units.
- Guard Mangler in OverlayCDB::getProjectModules() with `if (Mangler)` to
avoid calling an empty llvm::unique_function.
---
.../clangd/GlobalCompilationDatabase.cpp | 11 +-
clang-tools-extra/clangd/ModulesBuilder.cpp | 71 ++++--
clang-tools-extra/clangd/ProjectModules.cpp | 27 +++
clang-tools-extra/clangd/ProjectModules.h | 8 +
.../GlobalCompilationDatabaseTests.cpp | 18 ++
.../unittests/PrerequisiteModulesTest.cpp | 223 ++++++++++++++++++
6 files changed, 335 insertions(+), 23 deletions(-)
diff --git a/clang-tools-extra/clangd/GlobalCompilationDatabase.cpp b/clang-tools-extra/clangd/GlobalCompilationDatabase.cpp
index b7bb7f426d6150..553236c7d33603 100644
--- a/clang-tools-extra/clangd/GlobalCompilationDatabase.cpp
+++ b/clang-tools-extra/clangd/GlobalCompilationDatabase.cpp
@@ -856,10 +856,13 @@ OverlayCDB::getProjectModules(PathRef File) const {
log("Failed to get compilation Database for {0}", File);
return {};
}
- MDB->setCommandMangler([&Mangler = Mangler](tooling::CompileCommand &Command,
- PathRef CommandPath) {
- Mangler(Command, CommandPath);
- });
+ if (Mangler) {
+ MDB->setCommandMangler(
+ [&Mangler = Mangler](tooling::CompileCommand &Command,
+ PathRef CommandPath) {
+ Mangler(Command, CommandPath);
+ });
+ }
return MDB;
}
diff --git a/clang-tools-extra/clangd/ModulesBuilder.cpp b/clang-tools-extra/clangd/ModulesBuilder.cpp
index 72bb5b836d2012..f75f34f6eb1dac 100644
--- a/clang-tools-extra/clangd/ModulesBuilder.cpp
+++ b/clang-tools-extra/clangd/ModulesBuilder.cpp
@@ -94,17 +94,33 @@ std::string normalizePathForCache(PathRef Path) {
return maybeCaseFoldPath(Normalized);
}
+/// Returns the project source root owning \p ModuleUnitFileName, falling back
+/// to the consuming translation unit's (\p RequiredSource) project root when
+/// the module unit resides outside the workspace tree (e.g. system `std.cppm`).
+std::optional<std::string>
+getModuleProjectRoot(PathRef RequiredSource, PathRef ModuleUnitFileName,
+ const GlobalCompilationDatabase &CDB) {
+ if (auto PI = CDB.getProjectInfo(ModuleUnitFileName);
+ PI && !PI->SourceRoot.empty())
+ return PI->SourceRoot;
+ if (auto PI = CDB.getProjectInfo(RequiredSource);
+ PI && !PI->SourceRoot.empty())
+ return PI->SourceRoot;
+ return std::nullopt;
+}
+
/// Returns the root directory used for persistent module cache storage.
-/// Prefer a project-local cache so different clangd sessions working on the
+/// Prefer a project-local cache (resolved from the module unit or the
+/// consuming translation unit) so different clangd sessions working on the
/// same source tree can reuse BMIs. Fall back to the user cache directory, and
/// finally to a non-ephemeral temp directory when no better cache root exists.
llvm::SmallString<256>
-getModuleCacheRoot(PathRef ModuleUnitFileName,
+getModuleCacheRoot(PathRef RequiredSource, PathRef ModuleUnitFileName,
const GlobalCompilationDatabase &CDB) {
llvm::SmallString<256> Result;
- if (auto PI = CDB.getProjectInfo(ModuleUnitFileName);
- PI && !PI->SourceRoot.empty()) {
- Result = PI->SourceRoot;
+ if (auto ProjectRoot =
+ getModuleProjectRoot(RequiredSource, ModuleUnitFileName, CDB)) {
+ Result = *ProjectRoot;
llvm::sys::path::append(Result, ".cache", "clangd", "modules");
return Result;
}
@@ -123,9 +139,10 @@ getModuleCacheRoot(PathRef ModuleUnitFileName,
/// module cache. Placing locks beside the cache ensures all builders sharing
/// the cache also synchronize through the same lock namespace.
llvm::SmallString<256>
-getModuleCacheLocksDirectory(PathRef ModuleUnitFileName,
+getModuleCacheLocksDirectory(PathRef RequiredSource, PathRef ModuleUnitFileName,
const GlobalCompilationDatabase &CDB) {
- llvm::SmallString<256> Result = getModuleCacheRoot(ModuleUnitFileName, CDB);
+ llvm::SmallString<256> Result =
+ getModuleCacheRoot(RequiredSource, ModuleUnitFileName, CDB);
llvm::sys::path::append(Result, ".locks");
return Result;
}
@@ -162,10 +179,11 @@ std::string getCompileCommandStringHash(const tooling::CompileCommand &Cmd) {
/// basename alongside the source-hash, and the command-hash keeps incompatible
/// command lines apart.
llvm::SmallString<256>
-getModuleFilesDirectory(PathRef ModuleUnitFileName,
+getModuleFilesDirectory(PathRef RequiredSource, PathRef ModuleUnitFileName,
const tooling::CompileCommand &Cmd,
const GlobalCompilationDatabase &CDB) {
- llvm::SmallString<256> Result = getModuleCacheRoot(ModuleUnitFileName, CDB);
+ llvm::SmallString<256> Result =
+ getModuleCacheRoot(RequiredSource, ModuleUnitFileName, CDB);
llvm::sys::path::append(Result,
getModuleUnitSourceDirectoryName(ModuleUnitFileName),
getCompileCommandStringHash(Cmd));
@@ -175,10 +193,10 @@ getModuleFilesDirectory(PathRef ModuleUnitFileName,
/// Returns the lock file path guarding publication of BMIs for a module unit
/// source. Builders targeting the same source-hash serialize through this path.
llvm::SmallString<256>
-getModuleSourceHashLockPath(PathRef ModuleUnitFileName,
+getModuleSourceHashLockPath(PathRef RequiredSource, PathRef ModuleUnitFileName,
const GlobalCompilationDatabase &CDB) {
llvm::SmallString<256> Result =
- getModuleCacheLocksDirectory(ModuleUnitFileName, CDB);
+ getModuleCacheLocksDirectory(RequiredSource, ModuleUnitFileName, CDB);
llvm::sys::path::append(Result,
getModuleUnitSourcePathHash(ModuleUnitFileName));
return Result;
@@ -269,10 +287,11 @@ llvm::Error ensureLockAnchorFileExists(PathRef LockPath) {
class ScopedModuleSourceLock {
public:
static llvm::Expected<ScopedModuleSourceLock>
- acquire(PathRef ModuleUnitFileName, const GlobalCompilationDatabase &CDB) {
+ acquire(PathRef RequiredSource, PathRef ModuleUnitFileName,
+ const GlobalCompilationDatabase &CDB) {
constexpr auto LockWaitInterval = std::chrono::seconds(10);
llvm::SmallString<256> LockPath =
- getModuleSourceHashLockPath(ModuleUnitFileName, CDB);
+ getModuleSourceHashLockPath(RequiredSource, ModuleUnitFileName, CDB);
if (llvm::Error Err = ensureLockAnchorFileExists(LockPath))
return std::move(Err);
@@ -966,6 +985,11 @@ class CachingProjectModules : public ProjectModules {
return MDB->getModuleNameState(ModuleName);
}
+ std::optional<tooling::CompileCommand>
+ getCompileCommand(PathRef File) const override {
+ return MDB->getCompileCommand(File);
+ }
+
std::string getSourceForModuleName(llvm::StringRef ModuleName,
PathRef RequiredSrcFile) override {
auto ModuleState = MDB->getModuleNameState(ModuleName);
@@ -1152,6 +1176,7 @@ class ModulesBuilder::ModulesBuilderImpl {
/// Try to get prebuilt module files from the compilation database.
void getPrebuiltModuleFile(StringRef ModuleName, PathRef ModuleUnitFileName,
const ThreadsafeFS &TFS,
+ const CachingProjectModules &MDB,
ReusablePrerequisiteModules &BuiltModuleFiles);
/// Runs GC once for the cache root owning a project root.
@@ -1190,11 +1215,14 @@ void ModulesBuilder::ModulesBuilderImpl::
void ModulesBuilder::ModulesBuilderImpl::getPrebuiltModuleFile(
StringRef ModuleName, PathRef ModuleUnitFileName, const ThreadsafeFS &TFS,
+ const CachingProjectModules &MDB,
ReusablePrerequisiteModules &BuiltModuleFiles) {
if (!ReusePrebuiltModuleFile)
return;
auto Cmd = getCDB().getCompileCommand(ModuleUnitFileName);
+ if (!Cmd)
+ Cmd = MDB.getCompileCommand(ModuleUnitFileName);
if (!Cmd)
return;
@@ -1257,7 +1285,8 @@ llvm::Error ModulesBuilder::ModulesBuilderImpl::getOrBuildModuleFile(
/// Try to get prebuilt module files from the compilation database first. This
/// helps to avoid building the module files that are already built by the
/// compiler.
- getPrebuiltModuleFile(ModuleName, ModuleUnitFileName, TFS, BuiltModuleFiles);
+ getPrebuiltModuleFile(ModuleName, ModuleUnitFileName, TFS, MDB,
+ BuiltModuleFiles);
// Get Required modules in topological order.
auto ReqModuleNames = getAllRequiredModules(RequiredSource, MDB, ModuleName);
@@ -1268,20 +1297,24 @@ llvm::Error ModulesBuilder::ModulesBuilderImpl::getOrBuildModuleFile(
std::string ReqFileName =
MDB.getSourceForModuleName(ReqModuleName, RequiredSource);
auto Cmd = getCDB().getCompileCommand(ReqFileName);
+ if (!Cmd)
+ Cmd = MDB.getCompileCommand(ReqFileName);
if (!Cmd)
return llvm::createStringError(
llvm::formatv("No compile command for {0}", ReqFileName));
- if (auto PI = getCDB().getProjectInfo(ReqFileName);
- PI && !PI->SourceRoot.empty())
- garbageCollectModuleCacheForProjectRoot(PI->SourceRoot);
+ if (auto ProjectRoot =
+ getModuleProjectRoot(RequiredSource, ReqFileName, getCDB()))
+ garbageCollectModuleCacheForProjectRoot(*ProjectRoot);
const std::string CommandHash = getCompileCommandStringHash(*Cmd);
const std::string PublishedModuleFilePath = getPublishedModuleFilePath(
- ReqModuleName, getModuleFilesDirectory(ReqFileName, *Cmd, getCDB()));
+ ReqModuleName,
+ getModuleFilesDirectory(RequiredSource, ReqFileName, *Cmd, getCDB()));
// Keep the source-scoped lock while probing and validating cached BMIs so
// stale-file replacement and final publication stay serialized.
- auto SourceLock = ScopedModuleSourceLock::acquire(ReqFileName, getCDB());
+ auto SourceLock =
+ ScopedModuleSourceLock::acquire(RequiredSource, ReqFileName, getCDB());
if (!SourceLock)
return SourceLock.takeError();
diff --git a/clang-tools-extra/clangd/ProjectModules.cpp b/clang-tools-extra/clangd/ProjectModules.cpp
index 4ea38f4177fe9b..4b57d220bc7a6c 100644
--- a/clang-tools-extra/clangd/ProjectModules.cpp
+++ b/clang-tools-extra/clangd/ProjectModules.cpp
@@ -196,6 +196,14 @@ class ModuleDependencyScanner {
getRequiredModules(PathRef File,
const ProjectModules::CommandMangler &Mangler);
+ std::optional<tooling::CompileCommand>
+ getCompileCommand(PathRef FilePath,
+ const ProjectModules::CommandMangler &Mangler) const {
+ if (!CDB)
+ return std::nullopt;
+ return getCompileCommandForFile(*CDB, FilePath, Mangler);
+ }
+
private:
std::shared_ptr<const clang::tooling::CompilationDatabase> CDB;
@@ -344,6 +352,11 @@ class ScanningAllProjectModules : public ProjectModules {
return ModuleNameState::Unknown;
}
+ std::optional<tooling::CompileCommand>
+ getCompileCommand(PathRef File) const override {
+ return Scanner.getCompileCommand(File, Mangler);
+ }
+
private:
ModuleDependencyScanner Scanner;
CommandMangler Mangler;
@@ -429,6 +442,13 @@ class CompileCommandsProjectModules : public ProjectModules {
return SourceIt->second;
}
+ std::optional<tooling::CompileCommand>
+ getCompileCommand(PathRef File) const override {
+ if (!CDB)
+ return std::nullopt;
+ return getCompileCommandForFile(*CDB, File, Mangler);
+ }
+
void setCommandMangler(CommandMangler Mangler) override {
this->Mangler = std::move(Mangler);
ProducerCommandsIndexed = false;
@@ -567,6 +587,13 @@ class CompoundProjectModules : public ProjectModules {
return Scanning->getModuleNameState(ModuleName);
}
+ std::optional<tooling::CompileCommand>
+ getCompileCommand(PathRef File) const override {
+ if (auto Cmd = CompileCommands->getCompileCommand(File))
+ return Cmd;
+ return Scanning->getCompileCommand(File);
+ }
+
void setCommandMangler(CommandMangler Mangler) override {
this->Mangler = std::move(Mangler);
auto ForwardMangler = [this](tooling::CompileCommand &Command,
diff --git a/clang-tools-extra/clangd/ProjectModules.h b/clang-tools-extra/clangd/ProjectModules.h
index fbf658bafe1500..76e43f6bac7fc5 100644
--- a/clang-tools-extra/clangd/ProjectModules.h
+++ b/clang-tools-extra/clangd/ProjectModules.h
@@ -15,6 +15,7 @@
#include "clang/Tooling/CompilationDatabase.h"
#include <memory>
+#include <optional>
namespace clang {
namespace clangd {
@@ -55,6 +56,13 @@ class ProjectModules {
return ModuleNameState::Unknown;
}
+ /// Returns a compile command for \p File from this project's underlying
+ /// compilation database, with any configured CommandMangler applied.
+ virtual std::optional<tooling::CompileCommand>
+ getCompileCommand(PathRef File) const {
+ return std::nullopt;
+ }
+
virtual void setCommandMangler(CommandMangler Mangler) {}
virtual ~ProjectModules() = default;
diff --git a/clang-tools-extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp b/clang-tools-extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp
index 39ab1446e980b1..c380582f994f5c 100644
--- a/clang-tools-extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp
+++ b/clang-tools-extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp
@@ -14,6 +14,7 @@
#include "support/Path.h"
#include "support/ThreadsafeFS.h"
#include "clang/Tooling/CompilationDatabase.h"
+#include "clang/Tooling/JSONCompilationDatabase.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringRef.h"
@@ -92,6 +93,15 @@ class OverlayCDBTest : public ::testing::Test {
std::optional<ProjectInfo> getProjectInfo(PathRef File) const override {
return ProjectInfo{testRoot()};
}
+
+ std::unique_ptr<ProjectModules>
+ getProjectModules(PathRef File) const override {
+ MockFS TFS;
+ std::string Error;
+ auto JSONCDB = tooling::JSONCompilationDatabase::loadFromBuffer(
+ testRoot(), "[]", Error, tooling::JSONCommandLineSyntax::AutoDetect);
+ return clang::clangd::getProjectModules(std::move(JSONCDB), TFS);
+ }
};
protected:
@@ -179,6 +189,14 @@ TEST_F(OverlayCDBTest, Adjustments) {
"-DFallback", "-DAdjust_baz.cc"));
}
+TEST_F(OverlayCDBTest, GetProjectModulesWithoutMangler) {
+ OverlayCDB CDB(Base.get());
+ auto MDB = CDB.getProjectModules(testPath("foo.cc"));
+ ASSERT_NE(MDB, nullptr);
+ // Invoking ProjectModules queries must not crash when Mangler is empty.
+ EXPECT_EQ(MDB->getCompileCommand(testPath("foo.cc")), std::nullopt);
+}
+
TEST_F(OverlayCDBTest, ExpandedResponseFiles) {
SmallString<1024> Path;
int FD;
diff --git a/clang-tools-extra/clangd/unittests/PrerequisiteModulesTest.cpp b/clang-tools-extra/clangd/unittests/PrerequisiteModulesTest.cpp
index e878e2e0fa637b..8472821cf13412 100644
--- a/clang-tools-extra/clangd/unittests/PrerequisiteModulesTest.cpp
+++ b/clang-tools-extra/clangd/unittests/PrerequisiteModulesTest.cpp
@@ -14,6 +14,7 @@
#include "Annotations.h"
#include "CodeComplete.h"
#include "Compiler.h"
+#include "GlobalCompilationDatabase.h"
#include "ModulesBuilder.h"
#include "Preamble.h"
#include "ProjectModules.h"
@@ -68,6 +69,11 @@ class GlobalScanningCounterProjectModules : public ProjectModules {
return Underlying->getModuleNameState(ModuleName);
}
+ std::optional<tooling::CompileCommand>
+ getCompileCommand(PathRef File) const override {
+ return Underlying->getCompileCommand(File);
+ }
+
private:
std::unique_ptr<ProjectModules> Underlying;
std::atomic<unsigned> &Count;
@@ -1649,6 +1655,223 @@ export int BValue = MValue;
EXPECT_TRUE(StringRef(HSB.PrebuiltModuleFiles["M"]).contains("M.cppm-"));
}
+TEST_F(PrerequisiteModulesTests,
+ OutOfTreeModuleUnitResolvedViaConsumerCDBAndCachedInProject) {
+ SmallString<256> ProjectDir(TestDir);
+ llvm::sys::path::append(ProjectDir, "project");
+ SmallString<256> BuildDir(ProjectDir);
+ llvm::sys::path::append(BuildDir, "build");
+ SmallString<256> ExternalDir(TestDir);
+ llvm::sys::path::append(ExternalDir, "external");
+
+ ASSERT_FALSE(llvm::sys::fs::create_directories(BuildDir));
+ ASSERT_FALSE(llvm::sys::fs::create_directories(ExternalDir));
+
+ SmallString<256> ExtModPath(ExternalDir);
+ llvm::sys::path::append(ExtModPath, "M.cppm");
+ {
+ std::error_code EC;
+ llvm::raw_fd_ostream OS(ExtModPath, EC);
+ ASSERT_FALSE(EC);
+ OS << "export module M;\nexport int extVal = 42;\n";
+ }
+
+ SmallString<256> MainPath(ProjectDir);
+ llvm::sys::path::append(MainPath, "main.cpp");
+ {
+ std::error_code EC;
+ llvm::raw_fd_ostream OS(MainPath, EC);
+ ASSERT_FALSE(EC);
+ OS << "import M;\nint main() { return extVal; }\n";
+ }
+
+ SmallString<256> MPcmPath(BuildDir);
+ llvm::sys::path::append(MPcmPath, "M.pcm");
+
+ SmallString<256> CDBPath(BuildDir);
+ llvm::sys::path::append(CDBPath, "compile_commands.json");
+ {
+ std::error_code EC;
+ llvm::raw_fd_ostream OS(CDBPath, EC);
+ ASSERT_FALSE(EC);
+ std::string SlashBuild = llvm::sys::path::convert_to_slash(BuildDir);
+ std::string SlashExtMod = llvm::sys::path::convert_to_slash(ExtModPath);
+ std::string SlashMain = llvm::sys::path::convert_to_slash(MainPath);
+ std::string SlashPcm = llvm::sys::path::convert_to_slash(MPcmPath);
+ OS << llvm::formatv(
+ R"json([
+ {
+ "directory": "{0}",
+ "command": "clang++ -std=c++20 --precompile -o {3} {1}",
+ "file": "{1}"
+ },
+ {
+ "directory": "{0}",
+ "command": "clang++ -std=c++20 -fmodule-file=M={3} -c {2}",
+ "file": "{2}"
+ }
+])json",
+ SlashBuild, SlashExtMod, SlashMain, SlashPcm);
+ }
+
+ DirectoryBasedGlobalCompilationDatabase DirCDB(FS);
+ OverlayCDB CDB(&DirCDB);
+
+ // Out-of-tree module unit has no ancestor CDB of its own.
+ EXPECT_FALSE(CDB.getCompileCommand(ExtModPath));
+
+ ModulesBuilder Builder(CDB);
+ auto Info = Builder.buildPrerequisiteModulesFor(MainPath, FS);
+ ASSERT_TRUE(Info);
+
+ HeaderSearchOptions HS(ProjectDir);
+ Info->adjustHeaderSearchOptions(HS);
+ ASSERT_EQ(HS.PrebuiltModuleFiles.count("M"), 1u);
+ std::string BuiltPCMPath = HS.PrebuiltModuleFiles["M"];
+ EXPECT_TRUE(llvm::sys::fs::exists(BuiltPCMPath));
+
+ // Because the out-of-tree module unit has no project root, its persistent BMI
+ // cache must fall back to the consuming translation unit's project root.
+ SmallString<256> ExpectedCacheRoot(ProjectDir);
+ llvm::sys::path::append(ExpectedCacheRoot, ".cache", "clangd", "modules");
+ EXPECT_TRUE(StringRef(BuiltPCMPath).starts_with(ExpectedCacheRoot))
+ << "Actual BMI path: " << BuiltPCMPath
+ << "\nExpected prefix: " << ExpectedCacheRoot;
+
+ ParseInputs MainInputs = getInputs("project/main.cpp", CDB);
+ MainInputs.ModulesManager = &Builder;
+ auto CI = buildCompilerInvocation(MainInputs, DiagConsumer);
+ ASSERT_TRUE(CI);
+ EXPECT_TRUE(Info->canReuse(*CI, FS.view(ProjectDir)));
+
+ // Also verify getPrebuiltModuleFile() when an out-of-tree module unit
+ // itself consumes a prebuilt BMI via -fmodule-file= in compile_commands.json.
+ SmallString<256> DepModPath(ExternalDir);
+ llvm::sys::path::append(DepModPath, "Dep.cppm");
+ {
+ std::error_code EC;
+ llvm::raw_fd_ostream OS(DepModPath, EC);
+ ASSERT_FALSE(EC);
+ OS << "export module Dep;\nexport int depVal = 7;\n";
+ }
+
+ SmallString<256> DepPcmPath(BuildDir);
+ llvm::sys::path::append(DepPcmPath, "Dep.pcm");
+
+ // Build Dep.pcm once so a valid prebuilt BMI exists on disk.
+ {
+ std::string SlashBuild = llvm::sys::path::convert_to_slash(BuildDir);
+ std::string SlashDepMod = llvm::sys::path::convert_to_slash(DepModPath);
+ std::error_code EC;
+ llvm::raw_fd_ostream OS(CDBPath, EC);
+ ASSERT_FALSE(EC);
+ OS << llvm::formatv(
+ R"json([
+ {
+ "directory": "{0}",
+ "command": "clang++ -std=c++20 --precompile {1}",
+ "file": "{1}"
+ }
+])json",
+ SlashBuild, SlashDepMod);
+ }
+ {
+ DirectoryBasedGlobalCompilationDatabase SeedDirCDB(FS);
+ OverlayCDB SeedCDB(&SeedDirCDB);
+ ModulesBuilder SeedBuilder(SeedCDB);
+ // Build a temporary consumer of Dep to produce a valid BMI on disk.
+ SmallString<256> SeedMainPath(ProjectDir);
+ llvm::sys::path::append(SeedMainPath, "seed.cpp");
+ {
+ std::error_code EC;
+ llvm::raw_fd_ostream OS(SeedMainPath, EC);
+ ASSERT_FALSE(EC);
+ OS << "import Dep;\n";
+ }
+ {
+ std::string SlashBuild = llvm::sys::path::convert_to_slash(BuildDir);
+ std::string SlashDepMod = llvm::sys::path::convert_to_slash(DepModPath);
+ std::string SlashSeed = llvm::sys::path::convert_to_slash(SeedMainPath);
+ std::error_code EC;
+ llvm::raw_fd_ostream OS(CDBPath, EC);
+ ASSERT_FALSE(EC);
+ OS << llvm::formatv(
+ R"json([
+ {
+ "directory": "{0}",
+ "command": "clang++ -std=c++20 --precompile {1}",
+ "file": "{1}"
+ },
+ {
+ "directory": "{0}",
+ "command": "clang++ -std=c++20 -c {2}",
+ "file": "{2}"
+ }
+])json",
+ SlashBuild, SlashDepMod, SlashSeed);
+ }
+ auto SeedInfo = SeedBuilder.buildPrerequisiteModulesFor(SeedMainPath, FS);
+ ASSERT_TRUE(SeedInfo);
+ HeaderSearchOptions SeedHS(ProjectDir);
+ SeedInfo->adjustHeaderSearchOptions(SeedHS);
+ ASSERT_EQ(SeedHS.PrebuiltModuleFiles.count("Dep"), 1u);
+ ASSERT_FALSE(llvm::sys::fs::copy_file(SeedHS.PrebuiltModuleFiles["Dep"],
+ DepPcmPath));
+ }
+
+ // Now update external/M.cppm to import Dep and pass -fmodule-file=Dep=... on
+ // M.cppm's compile command in compile_commands.json.
+ {
+ std::error_code EC;
+ llvm::raw_fd_ostream OS(ExtModPath, EC);
+ ASSERT_FALSE(EC);
+ OS << "export module M;\nimport Dep;\nexport int extVal = depVal + 35;\n";
+ }
+ {
+ std::string SlashBuild = llvm::sys::path::convert_to_slash(BuildDir);
+ std::string SlashDepMod = llvm::sys::path::convert_to_slash(DepModPath);
+ std::string SlashExtMod = llvm::sys::path::convert_to_slash(ExtModPath);
+ std::string SlashMain = llvm::sys::path::convert_to_slash(MainPath);
+ std::string SlashDepPcm = llvm::sys::path::convert_to_slash(DepPcmPath);
+ std::string SlashMPcm = llvm::sys::path::convert_to_slash(MPcmPath);
+ std::error_code EC;
+ llvm::raw_fd_ostream OS(CDBPath, EC);
+ ASSERT_FALSE(EC);
+ OS << llvm::formatv(
+ R"json([
+ {
+ "directory": "{0}",
+ "command": "clang++ -std=c++20 --precompile -o {4} {1}",
+ "file": "{1}"
+ },
+ {
+ "directory": "{0}",
+ "command": "clang++ -std=c++20 -fmodule-file=Dep={4} --precompile -o {5} {2}",
+ "file": "{2}"
+ },
+ {
+ "directory": "{0}",
+ "command": "clang++ -std=c++20 -fmodule-file=M={5} -c {3}",
+ "file": "{3}"
+ }
+])json",
+ SlashBuild, SlashDepMod, SlashExtMod, SlashMain, SlashDepPcm,
+ SlashMPcm);
+ }
+
+ DirectoryBasedGlobalCompilationDatabase DirCDB2(FS);
+ OverlayCDB CDB2(&DirCDB2);
+ ModulesBuilder BuilderWithPrebuilt(CDB2);
+ auto PrebuiltInfo =
+ BuilderWithPrebuilt.buildPrerequisiteModulesFor(MainPath, FS);
+ ASSERT_TRUE(PrebuiltInfo);
+
+ HeaderSearchOptions PrebuiltHS(ProjectDir);
+ PrebuiltInfo->adjustHeaderSearchOptions(PrebuiltHS);
+ ASSERT_EQ(PrebuiltHS.PrebuiltModuleFiles.count("Dep"), 1u);
+ EXPECT_EQ(PrebuiltHS.PrebuiltModuleFiles["Dep"], std::string(DepPcmPath));
+}
+
TEST_F(PrerequisiteModulesTests, ModuleImportThroughInclude) {
MockDirectoryCompilationDatabase CDB(TestDir, FS);
More information about the cfe-commits
mailing list