[clangd] Suppress IncludeCleaner warnings for headers behind pragma keep

[kbobyrev]

Summary

D114072 allows filtering out the warnings for headers behind `// IWYU pragma:
keep`. This is the first step towards more useful IWYU pragmas support and
fine-grained control over the IncludeCleaner warnings.

[kadircet]

thanks, lgtm!

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

416

nit: just EXPECT_THAT(AST.getDiagnostics(), llvm::ValueIs(IsEmpty())) ?

418

nit: we mostly make use of a using decl for testing:: symbols in clangd unittests rather than qualifying at call sites. can you introduce a using decl for this one instead (and clean up the other occurrence)?

[kbobyrev]

Address review comments.

clang-tools-extra/clangd/IncludeCleaner.cpp

 }
 
 bool mayConsiderUnused(const Inclusion &Inc, ParsedAST &AST) {
   // FIXME(kirillbobyrev): We currently do not support the umbrella headers.
   // Standard Library headers are typically umbrella headers, and system
   // headers are likely to be the Standard Library headers. Until we have a
   // good support for umbrella headers and Standard Library headers, don't warn
   // about them.
-  if (Inc.Written.front() == '<')
+  if (Inc.Written.front() == '<' || Inc.BehindPragmaKeep)
     return false;
   // Headers without include guards have side effects and are not
   // self-contained, skip them.
   assert(Inc.HeaderID);
   auto FE = AST.getSourceManager().getFileManager().getFile(
       AST.getIncludeStructure().getRealPath(
           static_cast<IncludeStructure::HeaderID>(*Inc.HeaderID)));
   assert(FE);

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

 //===--- IncludeCleanerTests.cpp --------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Annotations.h"
 #include "IncludeCleaner.h"
 #include "TestTU.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
 using ::testing::ElementsAre;
+using ::testing::IsEmpty;
 using ::testing::UnorderedElementsAre;
 
 std::string guard(llvm::StringRef Code) {
   return "#pragma once\n" + Code.str();
 }
 
 TEST(IncludeCleaner, ReferencedLocations) {
   struct TestCase {
TEST(IncludeCleaner, VirtualBuffers) {
   auto ReferencedHeaders = translateToHeaderIDs(ReferencedFiles, Includes, SM);
   std::vector<llvm::StringRef> ReferencedHeaderNames;
   for (IncludeStructure::HeaderID HID : ReferencedHeaders)
     ReferencedHeaderNames.push_back(Includes.getRealPath(HID));
   // Non-header files are gone at this point.
   EXPECT_THAT(ReferencedHeaderNames, ElementsAre(testPath("macros.h")));
 
   // Sanity check.
-  EXPECT_THAT(getUnused(AST, ReferencedHeaders), ::testing::IsEmpty());
+  EXPECT_THAT(getUnused(AST, ReferencedHeaders), IsEmpty());
 }
 
 TEST(IncludeCleaner, DistinctUnguardedInclusions) {
   TestTU TU;
   TU.Code = R"cpp(
     #include "bar.h"
     #include "foo.h"
 
for (FileID FID : ReferencedFiles)
     ReferencedFileNames.insert(
         SM.getPresumedLoc(SM.getLocForStartOfFile(FID)).getFilename());
   // Note that we have uplifted the referenced files from non self-contained
   // headers to header-guarded ones.
   EXPECT_THAT(ReferencedFileNames.keys(),
               UnorderedElementsAre(testPath("foo.h")));
 }
 
+TEST(IncludeCleaner, IWYUPragmas) {
+  TestTU TU;
+  TU.Code = R"cpp(
+    #include "behind_keep.h" // IWYU pragma: keep
+    )cpp";
+  TU.AdditionalFiles["behind_keep.h"] = guard("");
+  ParsedAST AST = TU.build();
+
+  auto ReferencedFiles =
+      findReferencedFiles(findReferencedLocations(AST),
+                          AST.getIncludeStructure(), AST.getSourceManager());
+  EXPECT_TRUE(ReferencedFiles.empty());
+  EXPECT_THAT(AST.getDiagnostics(), llvm::ValueIs(IsEmpty()));
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang