[clangd] Move diagnostics from modules to the main source file

[DmitryPolukhin]

Summary

After https://reviews.llvm.org/D85753 these diagnostics silently dropped
so the user may not have an idea what is wrong. This diff moves
diagnostics to the start of the main file same as it happens with
errors in the command line. Also added prefix give to make it clear that the
location is not original.

Test Plan: check-clangd

[DmitryPolukhin]

Friendly ping, any thoughts about this diff?

clang-tools-extra/clangd/Diagnostics.cpp

static void fillNonLocationData(DiagnosticsEngine::Level DiagLevel,
   D.Severity = DiagLevel;
   D.Category = DiagnosticIDs::getCategoryNameFromID(
                    DiagnosticIDs::getCategoryNumberForDiag(Info.getID()))
                    .str();
 }
 
 void StoreDiags::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
                                   const clang::Diagnostic &Info) {
-  // If the diagnostic was generated for a different SourceManager, skip it.
+  bool FromModule = false;
+  // If the diagnostic was generated for a different SourceManager.
   // This happens when a module is imported and needs to be implicitly built.
   // The compilation of that module will use the same StoreDiags, but different
-  // SourceManager.
+  // SourceManager. Treat them as coming from command line.
   if (OrigSrcMgr && Info.hasSourceManager() &&
       OrigSrcMgr != &Info.getSourceManager()) {
-    IgnoreDiagnostics::log(DiagLevel, Info);
-    return;
+    FromModule = true;
   }
 
   DiagnosticConsumer::HandleDiagnostic(DiagLevel, Info);
   bool OriginallyError =
       Info.getDiags()->getDiagnosticIDs()->isDefaultMappingAsError(
           Info.getID());
 
-  if (Info.getLocation().isInvalid()) {
+  if (Info.getLocation().isInvalid() || FromModule) {
     // Handle diagnostics coming from command-line arguments. The source manager
     // is *not* available at this point, so we cannot use it.
     if (!OriginallyError) {
       IgnoreDiagnostics::log(DiagLevel, Info);
       return; // non-errors add too much noise, do not show them.
     }
 
     flushLastDiag();
 
     LastDiag = Diag();
     LastDiagLoc.reset();
     LastDiagOriginallyError = OriginallyError;
     LastDiag->ID = Info.getID();
     fillNonLocationData(DiagLevel, Info, *LastDiag);
+    // Update message to mention original location.
+    const char *Prefix =
+        FromModule ? "in implicitly built module" : "in command line";
+    LastDiag->Message = llvm::formatv("{0}: {1}", Prefix, LastDiag->Message);
+
     LastDiag->InsideMainFile = true;
     // Put it at the start of the main file, for a lack of a better place.
     LastDiag->Range.start = Position{0, 0};
     LastDiag->Range.end = Position{0, 0};
     return;
   }
 
   if (!LangOpts || !Info.hasSourceManager()) {

clang-tools-extra/clangd/unittests/ModulesTests.cpp

 
 #include <memory>
 #include <string>
 
 namespace clang {
 namespace clangd {
 namespace {
 
+using ::testing::ElementsAre;
+
+MATCHER_P(diag, Desc, "") {
+  return llvm::StringRef(arg.Message).contains(Desc);
+}
+
 TEST(Modules, TextualIncludeInPreamble) {
   TestTU TU = TestTU::withCode(R"cpp(
     #include "Textual.h"
 
     void foo() {}
 )cpp");
   TU.ExtraArgs.push_back("-fmodule-name=M");
   TU.ExtraArgs.push_back("-fmodule-map-file=" + testPath("m.modulemap"));
)cpp");
   TU.AdditionalFiles["non-modular.h"] = "";
   TU.AdditionalFiles["m.modulemap"] = R"modulemap(
     module M {
       header "modular.h"
     }
 )modulemap";
 
   // Test that we do not crash.
-  TU.build();
+  auto AST = TU.build();
+
+  // Test expected diagnostics.
+  EXPECT_THAT(AST.getDiagnostics(),
+              ElementsAre(diag("in implicitly built module: module M does not "
+                               "depend on a module exporting 'non-modular.h'"),
+                          diag("could not build module 'M'")));
 }
 
 // Unknown module formats are a fatal failure for clang. Ensure we don't crash.
 TEST(Modules, UnknownFormat) {
   TestTU TU = TestTU::withCode(R"(#include "modular.h")");
   TU.OverlayRealFileSystemForModules = true;
   TU.ExtraArgs.push_back("-Xclang");
   TU.ExtraArgs.push_back("-fmodule-format=obj");

clang-tools-extra/clangd/unittests/TUSchedulerTests.cpp

updateWithDiags(S, testPath("foo.cpp"), "void test() {}",
                   });
   Ready.wait();
 
   EXPECT_THAT(
       Diagnostics,
       ElementsAre(AllOf(
           Field(&Diag::ID, Eq(diag::err_drv_unknown_argument)),
           Field(&Diag::Name, Eq("drv_unknown_argument")),
-          Field(&Diag::Message, "unknown argument: '-fsome-unknown-flag'"))));
+          Field(&Diag::Message,
+                "in command line: unknown argument: '-fsome-unknown-flag'"))));
 }
 
 TEST_F(TUSchedulerTests, CommandLineWarnings) {
   // We should not see warnings from command-line parsing.
   CDB.ExtraClangFlags = {"-Wsome-unknown-warning"};
 
   // (!) 'Ready' must live longer than TUScheduler.
   Notification Ready;