[clangd] [C++20] [Modules] Introduce initial support for C++20 Modules

clang-tools-extra/clangd/ClangdLSPServer.cpp

@@ -53,8 +53,6 @@
 namespace clang {
 namespace clangd {
 
-extern llvm::cl::opt<bool> ExperimentalModulesSupport;
-
 namespace {
 // Tracks end-to-end latency of high level lsp calls. Measurements are in
 // seconds.

clang-tools-extra/clangd/ModulesBuilder.cpp

@@ -7,13 +7,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "ModulesBuilder.h"
-
 #include "Compiler.h"
 #include "support/Logger.h"
-
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/FrontendActions.h"
-
 #include "clang/Serialization/ASTReader.h"
 
 namespace clang {
@@ -142,8 +139,6 @@ class StandalonePrerequisiteModules : public PrerequisiteModules {
     ModuleFile(llvm::StringRef ModuleName, PathRef ModuleFilePath)
         : ModuleName(ModuleName.str()), ModuleFilePath(ModuleFilePath.str()) {}
 
-    ModuleFile() = delete;
-
     ModuleFile(const ModuleFile &) = delete;
     ModuleFile operator=(const ModuleFile &) = delete;
 
@@ -187,23 +182,21 @@ llvm::Error buildModuleFile(llvm::StringRef ModuleName,
   // third party modules, we should return true instead of false here.
   // Currently we simply bail out.
   if (ModuleUnitFileName.empty())
-    return llvm::createStringError(llvm::formatv(
-        "Failed to build '{0}': Failed to get the primary source", ModuleName));
+    return llvm::createStringError(
+        llvm::formatv("Failed to get the primary source"));
 
   // Try cheap operation earlier to boil-out cheaply if there are problems.
   auto Cmd = CDB.getCompileCommand(ModuleUnitFileName);
   if (!Cmd)
     return llvm::createStringError(
-        llvm::formatv("Failed to build '{0}': No compile command for {1}",
-                      ModuleName, ModuleUnitFileName));
+        llvm::formatv("No compile command for {0}", ModuleUnitFileName));
 
   for (auto &RequiredModuleName : MDB.getRequiredModules(ModuleUnitFileName)) {
     // Return early if there are errors building the module file.
     if (llvm::Error Err = buildModuleFile(RequiredModuleName, CDB, TFS, MDB,
                                           ModuleFilesPrefix, BuiltModuleFiles))
       return llvm::createStringError(
-          llvm::formatv("Failed to build dependency {0}: {1}",
-                        RequiredModuleName, toString(std::move(Err))));
+          llvm::formatv("Failed to build dependency {0}", RequiredModuleName));
   }
 
   Cmd->Output = getModuleFilePath(ModuleName, ModuleFilesPrefix);
@@ -215,16 +208,17 @@ llvm::Error buildModuleFile(llvm::StringRef ModuleName,
   IgnoreDiagnostics IgnoreDiags;
   auto CI = buildCompilerInvocation(Inputs, IgnoreDiags);
   if (!CI)
-    return llvm::createStringError(llvm::formatv(
-        "Failed to build '{0}': Failed to build compiler invocation for {1}",
-        ModuleName, ModuleUnitFileName));
+    return llvm::createStringError(
+        llvm::formatv("Failed to build compiler invocation"));
 
   auto FS = Inputs.TFS->view(Inputs.CompileCommand.Directory);
   auto Buf = FS->getBufferForFile(Inputs.CompileCommand.Filename);
   if (!Buf)
-    return llvm::createStringError(
-        llvm::formatv("Failed to build '{0}': Failed to create buffer for {1}",
-                      ModuleName, Inputs.CompileCommand.Filename));
+    return llvm::createStringError(llvm::formatv("Failed to create buffer"));
+
+  // In clang's driver, we will suppress the check for ODR violation in GMF.
+  // See the implementation of RenderModulesOptions in Clang.cpp.
+  CI->getLangOpts().SkipODRCheckInGMF = true;
 
   // Hash the contents of input files and store the hash value to the BMI files.
   // So that we can check if the files are still valid when we want to reuse the
@@ -238,17 +232,14 @@ llvm::Error buildModuleFile(llvm::StringRef ModuleName,
       prepareCompilerInstance(std::move(CI), /*Preamble=*/nullptr,
                               std::move(*Buf), std::move(FS), IgnoreDiags);
   if (!Clang)
-    return llvm::createStringError(llvm::formatv(
-        "Failed to build '{0}': Failed to prepare compiler instance for {0}",
-        ModuleName, ModuleUnitFileName));
+    return llvm::createStringError(
+        llvm::formatv("Failed to prepare compiler instance"));
 
-  GenerateModuleInterfaceAction Action;
+  GenerateReducedModuleInterfaceAction Action;
   Clang->ExecuteAction(Action);
 
   if (Clang->getDiagnostics().hasErrorOccurred())
-    return llvm::createStringError(
-        llvm::formatv("Failed to build '{0}': Compilation for {1} failed",
-                      ModuleName, ModuleUnitFileName));
+    return llvm::createStringError(llvm::formatv("Compilation failed"));
 
   BuiltModuleFiles.addModuleFile(ModuleName, Inputs.CompileCommand.Output);
   return llvm::Error::success();
@@ -318,6 +309,10 @@ bool StandalonePrerequisiteModules::canReuse(
   Clang.getHeaderSearchOpts().ForceCheckCXX20ModulesInputFiles = true;
   Clang.getHeaderSearchOpts().ValidateASTInputFilesContent = true;
 
+  // Following the practice of clang's driver to suppres the checking for ODR
+  // violation in GMF.
+  Clang.getLangOpts().SkipODRCheckInGMF = true;
+
   Clang.createASTReader();
   for (auto &RequiredModule : RequiredModules) {
     llvm::StringRef BMIPath = RequiredModule.ModuleFilePath;

clang-tools-extra/clangd/ModulesBuilder.h

@@ -22,14 +22,10 @@
 
 #include "GlobalCompilationDatabase.h"
 #include "ProjectModules.h"
-
 #include "support/Path.h"
 #include "support/ThreadsafeFS.h"
-
 #include "clang/Frontend/CompilerInvocation.h"
-
 #include "llvm/ADT/SmallString.h"
-
 #include <memory>
 
 namespace clang {

clang-tools-extra/clangd/ScanningProjectModules.cpp

@@ -7,9 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "ProjectModules.h"
-
 #include "support/Logger.h"
-
+#include "clang/Driver/Driver.h"
 #include "clang/Tooling/DependencyScanning/DependencyScanningService.h"
 #include "clang/Tooling/DependencyScanning/DependencyScanningTool.h"
 
@@ -99,6 +98,12 @@ ModuleDependencyScanner::scan(PathRef FilePath) {
   // DirectoryBasedGlobalCompilationDatabase::getCompileCommand.
   tooling::CompileCommand Cmd = std::move(Candidates.front());
 
+  Cmd.CommandLine.push_back("-I");
+  llvm::SmallString<256> ResourceDir(clang::driver::Driver::GetResourcesPath(
+      llvm::sys::fs::getMainExecutable(nullptr, nullptr)));
+  llvm::sys::path::append(ResourceDir, "include");
+  Cmd.CommandLine.push_back((std::string)ResourceDir);
+
   using namespace clang::tooling::dependencies;
 
   llvm::SmallString<128> FilePathDir(FilePath);

clang-tools-extra/clangd/tool/Check.cpp

@@ -146,10 +146,13 @@ class Checker {
   ClangdLSPServer::Options Opts;
   // from buildCommand
   tooling::CompileCommand Cmd;
+  std::unique_ptr<GlobalCompilationDatabase> BaseCDB;
+  std::unique_ptr<GlobalCompilationDatabase> CDB;
   // from buildInvocation
   ParseInputs Inputs;
   std::unique_ptr<CompilerInvocation> Invocation;
   format::FormatStyle Style;
+  std::optional<ModulesBuilder> ModulesManager;
   // from buildAST
   std::shared_ptr<const PreambleData> Preamble;
   std::optional<ParsedAST> AST;
@@ -168,14 +171,14 @@ class Checker {
     DirectoryBasedGlobalCompilationDatabase::Options CDBOpts(TFS);
     CDBOpts.CompileCommandsDir =
         Config::current().CompileFlags.CDBSearch.FixedCDBPath;
-    std::unique_ptr<GlobalCompilationDatabase> BaseCDB =
+    BaseCDB =
         std::make_unique<DirectoryBasedGlobalCompilationDatabase>(CDBOpts);
     auto Mangler = CommandMangler::detect();
     Mangler.SystemIncludeExtractor =
         getSystemIncludeExtractor(llvm::ArrayRef(Opts.QueryDriverGlobs));
     if (Opts.ResourceDir)
       Mangler.ResourceDir = *Opts.ResourceDir;
-    auto CDB = std::make_unique<OverlayCDB>(
+    CDB = std::make_unique<OverlayCDB>(
         BaseCDB.get(), std::vector<std::string>{}, std::move(Mangler));
 
     if (auto TrueCmd = CDB->getCompileCommand(File)) {
@@ -213,6 +216,11 @@ class Checker {
         return false;
       }
     }
+    if (Opts.EnableExperimentalModulesSupport) {
+      if (!ModulesManager)
+        ModulesManager.emplace(*CDB);
+      Inputs.ModulesManager = &*ModulesManager;
+    }
     log("Parsing command...");
     Invocation =
         buildCompilerInvocation(Inputs, CaptureInvocationDiags, &CC1Args);