[clangd] Support iwyu pragma: no_include

[zyounan]

Summary

This patch is one of the steps trying to optimize experience
of header insertion in code completion.
IWYU supports no_include pragma that helps user to get rid
of specified headers in main file.
The patch consists of two parts: Code completion part that
prevent auto insertion if the header to be inserted is under
the guard of no_include pragma. The other part is for include
cleaner, which emits diagnostic message pointing out that user
is including no_include headers.

A possible workaround for clangd/clangd#1481.

[zyounan]

Remove extra headers

[zyounan]

Update test

[zyounan]

Update tests && Use Preprocessor.LookupFile

[zyounan]

Fix test on windows

[zyounan]

Ping

[kadircet]

thanks a lot for the patch!

we're migrating IWYU related functionality in clangd to make use of include-cleaner library nowadays. so can you actually move the IWYU no_include pragma handling logic into https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/include-cleaner/lib/Record.cpp?
This won't have affect on clangd regarding the particular problem you're facing immediately, but we're going to merge the logic inside include-cleaner and clangd soon and such discrepancies should disappear then.

in the meanwhile regarding the particular problem you're facing for experimental symbols. sorry for shutting down D142836, but that actually made us re-evaluate the approach of hand-curated lists and we've decided to introduce such mappings. so if you can revamp D142836 and put TsStdSymbolMap.inc in https://github.com/llvm/llvm-project/tree/main/clang/lib/Tooling/Inclusions/Stdlib/StdTsSymbolMap.inc we can land it and make sure it work as intended inside clangd, even before we merge the IWYU pragma handling logic. Happy to do that myself if you don't feel like doing it, sorry for creating some confusion here :(

[zyounan]

In D143319#4115186, @kadircet wrote:

thanks a lot for the patch!

we're migrating IWYU related functionality in clangd to make use of include-cleaner library nowadays. so can you actually move the IWYU no_include pragma handling logic into https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/include-cleaner/lib/Record.cpp?
This won't have affect on clangd regarding the particular problem you're facing immediately, but we're going to merge the logic inside include-cleaner and clangd soon and such discrepancies should disappear then.

in the meanwhile regarding the particular problem you're facing for experimental symbols. sorry for shutting down D142836, but that actually made us re-evaluate the approach of hand-curated lists and we've decided to introduce such mappings. so if you can revamp D142836 and put TsStdSymbolMap.inc in https://github.com/llvm/llvm-project/tree/main/clang/lib/Tooling/Inclusions/Stdlib/StdTsSymbolMap.inc we can land it and make sure it work as intended inside clangd, even before we merge the IWYU pragma handling logic. Happy to do that myself if you don't feel like doing it, sorry for creating some confusion here :(

Although I'm convinced that they're not stable enough to migrate into Stdlib directory, I'm still glad to hear that we're going to support TS symbols.
And certainly, I'd love to revamp D142836, while I believe that this IWYU no-include is a more general approach than that ad-hoc way.

[zyounan]

Sorry for the late update :)
Move parsing logic to Record.cpp now.

[hokein]

Thanks for the patch, and sorry for the long delay.

You probably need to do a large rebase when updating this patch (since the include-cleaner clangd code has been changed a lot)

This is a big patch, touching several pieces (I'd suggest split this patch, and narrow its scope.):

1. support no_include pragma in include-cleaner library (I made some comments regarding the implementation)
2. usage of no_include pragma:
   • 2.1 include-cleaner diagnostics in clangd -- for missing-includes, we should not insert a spelled include when it is in the NoIncludeSet;
   • 2.2 global code completion respects no_include pragma

It makes sense to support 1 and 2.1. And 2.2 is nice to have -- global code completion was built long time ago, and we haven't heard of any user complains, I'm less certain, it is probably fine if it is trivial to implement.

clang-tools-extra/clangd/IncludeCleaner.cpp

579

I'm not sure it is worth to make a dedicated function for this marginal pragma, I think we can treat it as an unused-include case, and we can move it to issueUnusedIncludesDiagnostics.

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Record.h

44

I think we can do it simpler. The Resolved field is no used anywhere, and is expensive to get.

The critical information to store is the header spelled in the no_include pragma, so having a StringSet<> NoIncludes field in PragmaIncludes should be sufficient.

165

This is not a specific issue for no_include pragma, it is a known limitation -- ideally we should make PragmaIncludes collect all IWYU pragmas outside of the preamble region, tracking in https://github.com/clangd/clangd/issues/1571.
I think we should merge this logic to the PragmaIncludes structure.

clang-tools-extra/clangd/CodeComplete.cpp

auto RecorderOwner = std::make_unique<CompletionRecorder>(Opts, [&]() {
       // If preprocessor was run, inclusions from preprocessor callback should
       // already be added to Includes.
       Inserter.emplace(
           SemaCCInput.FileName, SemaCCInput.ParseInput.Contents, Style,
           SemaCCInput.ParseInput.CompileCommand.Directory,
           &Recorder->CCSema->getPreprocessor().getHeaderSearchInfo());
       for (const auto &Inc : Includes.MainFileIncludes)
         Inserter->addExisting(Inc);
+      for (const auto &Inc : Includes.RecordedNoIncludes.IwyuNoIncludes)
+        Inserter->addNoInclude(Inc);
 
       // Most of the cost of file proximity is in initializing the FileDistance
       // structures based on the observed includes, once per query. Conceptually
       // that happens here (though the per-URI-scheme initialization is lazy).
       // The per-result proximity scoring is (amortized) very cheap.
       FileDistanceOptions ProxOpts{}; // Use defaults.
       const auto &SM = Recorder->CCSema->getSourceManager();
       llvm::StringMap<SourceParams> ProxSources;

clang-tools-extra/clangd/Headers.h

 //===--- Headers.h - Include headers -----------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_HEADERS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_HEADERS_H
 
 #include "Protocol.h"
 #include "SourceCode.h"
+#include "clang-include-cleaner/Record.h"
 #include "index/Symbol.h"
 #include "support/Path.h"
 #include "clang/Basic/FileEntry.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Format/Format.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
public:
 
   // We reserve HeaderID(0) for the main file and will manually check for that
   // in getID and getOrCreateID because the UniqueID is not stable when the
   // content of the main file changes.
   static const HeaderID MainFileID = HeaderID(0u);
 
   class RecordHeaders;
 
+  include_cleaner::RecordedNoIncludes RecordedNoIncludes;
+
 private:
   // MainFileEntry will be used to check if the queried file is the main file
   // or not.
   const FileEntry *MainFileEntry = nullptr;
 
   std::vector<std::string> RealPathNames; // In HeaderID order.
   // FileEntry::UniqueID is mapped to the internal representation (HeaderID).
   // Identifying files in a way that persists from preamble build to subsequent
IncludeInserter(StringRef FileName, StringRef Code,
                   const format::FormatStyle &Style, StringRef BuildDir,
                   HeaderSearch *HeaderSearchInfo)
       : FileName(FileName), Code(Code), BuildDir(BuildDir),
         HeaderSearchInfo(HeaderSearchInfo),
         Inserter(FileName, Code, Style.IncludeStyle) {}
 
   void addExisting(const Inclusion &Inc);
 
+  void addNoInclude(const include_cleaner::IwyuNoInclude &Inc);
+
   /// Checks whether to add an #include of the header into \p File.
   /// An #include will not be added if:
   ///   - Either \p DeclaringHeader or \p InsertedHeader is already (directly)
   ///   in \p Inclusions (including those included via different paths).
   ///   - \p DeclaringHeader or \p InsertedHeader is the same as \p File.
   ///
   /// \param DeclaringHeader is path of the original header corresponding to \p
   /// InsertedHeader e.g. the header that declares a symbol.
std::optional<TextEdit> insert(llvm::StringRef VerbatimHeader,
                                  tooling::IncludeDirective Directive) const;
 
 private:
   StringRef FileName;
   StringRef Code;
   StringRef BuildDir;
   HeaderSearch *HeaderSearchInfo = nullptr;
   llvm::StringSet<> IncludedHeaders; // Both written and resolved.
-  tooling::HeaderIncludes Inserter;  // Computers insertion replacement.
+  llvm::StringSet<> IwyuNoIncludeHeaders; // Iwyu: no_include headers, with
+                                          // written and resolved.
+  tooling::HeaderIncludes Inserter;       // Computers insertion replacement.
 };
 
 } // namespace clangd
 } // namespace clang
 
 namespace llvm {
 
 // Support HeaderIDs as DenseMap keys.

clang-tools-extra/clangd/Headers.cpp

 //===--- Headers.cpp - Include headers ---------------------------*- 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 "Headers.h"
 #include "Preamble.h"
 #include "SourceCode.h"
+#include "clang-include-cleaner/Record.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/Inclusions/HeaderAnalysis.h"
 #include "llvm/ADT/StringRef.h"

 }
 
 void IncludeStructure::collect(const CompilerInstance &CI) {
   auto &SM = CI.getSourceManager();
   MainFileEntry = SM.getFileEntryForID(SM.getMainFileID());
   auto Collector = std::make_unique<RecordHeaders>(CI, this);
   CI.getPreprocessor().addCommentHandler(Collector.get());
   CI.getPreprocessor().addPPCallbacks(std::move(Collector));
+  RecordedNoIncludes.record(CI);
 }
 
 std::optional<IncludeStructure::HeaderID>
 IncludeStructure::getID(const FileEntry *Entry) const {
   // HeaderID of the main file is always 0;
   if (Entry == MainFileEntry) {
     return static_cast<IncludeStructure::HeaderID>(0u);
   }

 }
 
 void IncludeInserter::addExisting(const Inclusion &Inc) {
   IncludedHeaders.insert(Inc.Written);
   if (!Inc.Resolved.empty())
     IncludedHeaders.insert(Inc.Resolved);
 }
 
+void IncludeInserter::addNoInclude(const include_cleaner::IwyuNoInclude &Inc) {
+  IwyuNoIncludeHeaders.insert(Inc.Written);
+  if (!Inc.Resolved.empty())
+    IwyuNoIncludeHeaders.insert(Inc.Resolved);
+}
+
 /// FIXME(ioeric): we might not want to insert an absolute include path if the
 /// path is not shortened.
 bool IncludeInserter::shouldInsertInclude(
     PathRef DeclaringHeader, const HeaderFile &InsertedHeader) const {
   assert(InsertedHeader.valid());
   if (!HeaderSearchInfo && !InsertedHeader.Verbatim)
     return false;
   if (FileName == DeclaringHeader || FileName == InsertedHeader.File)
     return false;
   auto Included = [&](llvm::StringRef Header) {
     return IncludedHeaders.find(Header) != IncludedHeaders.end();
   };
-  return !Included(DeclaringHeader) && !Included(InsertedHeader.File);
+  auto IsIwyuNoInclude = [&](llvm::StringRef Header) {
+    return IwyuNoIncludeHeaders.find(Header) != IwyuNoIncludeHeaders.end();
+  };
+  auto ShouldInsert = [&](auto &Predicate) {
+    return !Predicate(DeclaringHeader) && !Predicate(InsertedHeader.File);
+  };
+  return ShouldInsert(Included) && ShouldInsert(IsIwyuNoInclude);
 }
 
 std::optional<std::string>
 IncludeInserter::calculateIncludePath(const HeaderFile &InsertedHeader,
                                       llvm::StringRef IncludingFile) const {
   assert(InsertedHeader.valid());
   if (InsertedHeader.Verbatim)
     return InsertedHeader.File;

clang-tools-extra/clangd/IncludeCleaner.h

 // The same as computeUnusedIncludes, but it is an experimental and
 // include-cleaner-lib-based implementation.
 std::vector<const Inclusion *>
 computeUnusedIncludesExperimental(ParsedAST &AST);
 
 std::vector<Diag> issueUnusedIncludesDiagnostics(ParsedAST &AST,
                                                  llvm::StringRef Code);
 
+std::vector<Diag> issueNoIncludesDiagnostics(ParsedAST &AST,
+                                             llvm::StringRef Code);
+
 /// Affects whether standard library includes should be considered for
 /// removal. This is off by default for now due to implementation limitations:
 /// - macros are not tracked
 /// - symbol names without a unique associated header are not tracked
 /// - references to std-namespaced C types are not properly tracked:
 ///   instead of std::size_t -> <cstddef> we see ::size_t -> <stddef.h>
 /// FIXME: remove this hack once the implementation is good enough.
 void setIncludeCleanerAnalyzesStdlib(bool B);
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDECLEANER_H

clang-tools-extra/clangd/IncludeCleaner.cpp

for (const auto *Inc : UnusedIncludes) {
     D.Fixes.back().Edits.back().range.start.line = Inc->HashLine;
     D.Fixes.back().Edits.back().range.end.line = Inc->HashLine + 1;
     D.InsideMainFile = true;
     Result.push_back(std::move(D));
   }
   return Result;
 }
 
+std::vector<Diag> issueNoIncludesDiagnostics(ParsedAST &AST,
+                                             llvm::StringRef Code) {
+  // C/C++ only
+  if (AST.getLangOpts().ObjC)
+    return {};
+  std::vector<Diag> Result;
+  std::string FileName =
+      AST.getSourceManager()
+          .getFileEntryRefForID(AST.getSourceManager().getMainFileID())
+          ->getName()
+          .str();
+  auto &NoIncludes =
+      AST.getIncludeStructure().RecordedNoIncludes.IwyuNoIncludes;
+  if (NoIncludes.empty())
+    return {};
+  for (auto &Inc : AST.getIncludeStructure().MainFileIncludes) {
+    const auto It = NoIncludes.find(include_cleaner::IwyuNoInclude(
+        Inc.Written, Inc.Resolved, Inc.HashLine));
+    if (It == NoIncludes.end())
+      continue;
+    Diag D;
+    D.Message = llvm::formatv(
+        "included header '{0}' is marked as `no_include` at line {1}",
+        StringRef(Inc.Written).trim("<>\""), It->HashLine + 1);
+    D.Name = "no-include-headers";
+    D.Source = Diag::DiagSource::Clangd;
+    D.File = FileName;
+    D.Severity = DiagnosticsEngine::Warning;
+    D.Tags.push_back(Unnecessary);
+    D.Range = getDiagnosticRange(Code, Inc.HashOffset);
+    D.Fixes.emplace_back();
+    D.Fixes.back().Message = "remove #include directive";
+    D.Fixes.back().Edits.emplace_back();
+    D.Fixes.back().Edits.back().range.start.line = Inc.HashLine;
+    D.Fixes.back().Edits.back().range.end.line = Inc.HashLine + 1;
+    D.InsideMainFile = true;
+    Result.push_back(std::move(D));
+  }
+  return Result;
+}
+
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/ParsedAST.cpp

if (Inputs.Index && !BuildDir.getError()) {
       auto Inserter = std::make_shared<IncludeInserter>(
           Filename, Inputs.Contents, Style, BuildDir.get(),
           &Clang->getPreprocessor().getHeaderSearchInfo());
       ArrayRef<Inclusion> MainFileIncludes;
       if (Preamble) {
         MainFileIncludes = Preamble->Includes.MainFileIncludes;
         for (const auto &Inc : Preamble->Includes.MainFileIncludes)
           Inserter->addExisting(Inc);
+        for (const auto &NoInc :
+             Preamble->Includes.RecordedNoIncludes.IwyuNoIncludes)
+          Inserter->addNoInclude(NoInc);
       }
       // FIXME: Consider piping through ASTSignals to fetch this to handle the
       // case where a header file contains ObjC decls but no #imports.
       Symbol::IncludeDirective Directive =
           Inputs.Opts.ImportInsertions
               ? preferredIncludeDirective(Filename, Clang->getLangOpts(),
                                           MainFileIncludes, {})
               : Symbol::Include;
ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
   ParsedAST Result(Filename, Inputs.Version, std::move(Preamble),
                    std::move(Clang), std::move(Action), std::move(Tokens),
                    std::move(Macros), std::move(Marks), std::move(ParsedDecls),
                    std::move(Diags), std::move(Includes),
                    std::move(CanonIncludes));
   if (Result.Diags) {
     auto UnusedHeadersDiags =
         issueUnusedIncludesDiagnostics(Result, Inputs.Contents);
+    auto NoIncludeHeadersDiags =
+        issueNoIncludesDiagnostics(Result, Inputs.Contents);
     Result.Diags->insert(Result.Diags->end(),
                          make_move_iterator(UnusedHeadersDiags.begin()),
                          make_move_iterator(UnusedHeadersDiags.end()));
+    Result.Diags->insert(Result.Diags->end(),
+                         make_move_iterator(NoIncludeHeadersDiags.begin()),
+                         make_move_iterator(NoIncludeHeadersDiags.end()));
   }
   return std::move(Result);
 }
 
 ParsedAST::ParsedAST(ParsedAST &&Other) = default;
 
 ParsedAST &ParsedAST::operator=(ParsedAST &&Other) = default;
 

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

auto Results = completions(R"cpp(
           int main() { ns::^ }
       )cpp",
                              {SymX, SymY});
   EXPECT_THAT(Results.Completions,
               ElementsAre(AllOf(named("X"), Not(insertInclude())),
                           AllOf(named("Y"), Not(insertInclude()))));
 }
 
+TEST(CompletionTest, NoIncludeInsertionIfSpecifiedInNoIncludePragma) {
+  Symbol SymX = cls("ns::X");
+  std::string BarHeader = testPath("sub/bar");
+  auto BarURI = URI::create(BarHeader).toString();
+  SymX.CanonicalDeclaration.FileURI = BarURI.c_str();
+  SymX.IncludeHeaders.emplace_back("<bar>", 1, Symbol::Include);
+  TestTU TU;
+  TU.Code = R"cpp(
+          // IWYU pragma: no_include <bar>
+          namespace ns {}
+          int main() { ns::^ }
+      )cpp";
+  TU.AdditionalFiles["sub/bar"] = "";
+  Annotations Test(TU.Code);
+  TU.ExtraArgs.emplace_back("-I" + testPath("sub"));
+  auto Results = completions(TU, Test.point(), {SymX});
+  EXPECT_THAT(Results.Completions,
+              ElementsAre(AllOf(named("X"), Not(insertInclude()))));
+}
+
 TEST(CompletionTest, IndexSuppressesPreambleCompletions) {
   Annotations Test(R"cpp(
       #include "bar.h"
       namespace ns { int local; }
       void f() { ns::^; }
       void f2() { ns::preamble().$2^; }
   )cpp");
   auto TU = TestTU::withCode(Test.code());

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 "Config.h"
 #include "IncludeCleaner.h"
+#include "Protocol.h"
 #include "SourceCode.h"
 #include "TestFS.h"
 #include "TestTU.h"
 #include "support/Context.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Testing/Support/SupportHelpers.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
+using ::testing::AllOf;
 using ::testing::ElementsAre;
 using ::testing::ElementsAreArray;
+using ::testing::Field;
 using ::testing::IsEmpty;
 using ::testing::Pointee;
 using ::testing::UnorderedElementsAre;
 
 std::string guard(llvm::StringRef Code) {
   return "#pragma once\n" + Code.str();
 }
 
TEST(IncludeCleaner, IWYUPragmaExport) {
 
   EXPECT_THAT(AST.getDiagnostics(), llvm::ValueIs(IsEmpty()));
   // FIXME: This is not correct: foo.h is unused but is not diagnosed as such
   // because we ignore headers with IWYU export pragmas for now.
   EXPECT_THAT(computeUnusedIncludes(AST), IsEmpty());
   EXPECT_THAT(computeUnusedIncludesExperimental(AST), IsEmpty());
 }
 
+MATCHER_P(message, Message, "") { return arg.Message == Message; }
+MATCHER_P2(range, Start, End, "") {
+  return arg.start == Start && arg.end == End;
+}
+
+TEST(IncludeCleaner, IWYUPragmaNoInclude) {
+  Config Cfg;
+  Cfg.Diagnostics.UnusedIncludes = Config::Experiment;
+  WithContextValue Ctx(Config::Key, std::move(Cfg));
+  TestTU TU;
+  TU.Code = R"cpp(
+#include "foo.h"
+#include "bar.h"
+// IWYU pragma: no_include "bar.h"
+  )cpp";
+  TU.AdditionalFiles["foo.h"] = guard("");
+  TU.AdditionalFiles["bar.h"] = guard("");
+  ParsedAST AST = TU.build();
+
+  auto Diags = issueNoIncludesDiagnostics(AST, TU.Code);
+  EXPECT_THAT(
+      Diags,
+      UnorderedElementsAre(AllOf(
+          message(
+              "included header 'bar.h' is marked as `no_include` at line 4"),
+          Field(&DiagBase::Range, range(Position{2, 0}, Position{2, 16})))));
+  ASSERT_TRUE(Diags.size() == 1);
+  ASSERT_TRUE(Diags.back().Fixes.size() == 1);
+  ASSERT_TRUE(Diags.back().Fixes.back().Edits.size() == 1);
+  EXPECT_THAT(Diags.back().Fixes.back().Edits.back().range,
+              range(Position{2, 0}, Position{3, 0}));
+}
+
 TEST(IncludeCleaner, NoDiagsForObjC) {
   TestTU TU;
   TU.Code = R"cpp(
     #include "foo.h"
 
     void bar() {}
     )cpp";
   TU.AdditionalFiles["foo.h"] = R"cpp(

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Record.h

 // but other ways are possible (for example clangd records includes separately).
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef CLANG_INCLUDE_CLEANER_RECORD_H
 #define CLANG_INCLUDE_CLEANER_RECORD_H
 
 #include "clang-include-cleaner/Types.h"
+#include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/FileSystem/UniqueID.h"
 #include <memory>
+#include <set>
 #include <vector>
 
 namespace clang {
 class ASTConsumer;
 class ASTContext;
 class CompilerInstance;
 class Decl;
 class FileEntry;
 class Preprocessor;
 class PPCallbacks;
 class FileManager;
 
 namespace include_cleaner {
 
+struct IwyuNoInclude {
+  std::string
+      Written; // For `IWYU pragma no_include <vector>`, it is `<vector>`.
+  std::string Resolved; // Resolved path to written file.
+  int HashLine;         // 0-based line number containing IWYU pragma
+  IwyuNoInclude() = default;
+  IwyuNoInclude(std::string Written, std::string Resolved, int HashLine)
+      : Written(std::move(Written)), Resolved(std::move(Resolved)),
+        HashLine(HashLine) {}
+  friend bool operator<(const IwyuNoInclude &LHS, const IwyuNoInclude &RHS) {
+    // We want only 1 pragma for the same written header.
+    return LHS.Written < RHS.Written;
+  }
+};
+
 /// Captures #include mapping information. It analyses IWYU Pragma comments and
 /// other use-instead-like mechanisms (#pragma include_instead) on included
 /// files.
 ///
 /// This is a low-level piece being used in the "Location => Header" analysis
 /// step to determine the final public header rather than the header directly
 /// defines the symbol.
 class PragmaIncludes {
struct RecordedPP {
 
   /// Describes where macros were used in the main file.
   std::vector<SymbolReference> MacroReferences;
 
   /// The include directives seen in the main file.
   include_cleaner::Includes Includes;
 };
 
+/// Collects IWYU no_include directives. We don't put the parse logic in
+/// \class PragmaIncludes because the directive could be scattered throughout
+/// the source rather than being limited in preamble bounds.
+struct RecordedNoIncludes {
+  /// The callback (when installed into clang) tracks no_includes pragma in
+  /// this.
+  void record(const CompilerInstance &Clang);
+
+  /// no_include directives.
+  std::set<IwyuNoInclude> IwyuNoIncludes;
+};
+
 } // namespace include_cleaner
 } // namespace clang
 
 #endif

clang-tools-extra/include-cleaner/lib/Record.cpp

std::unique_ptr<ASTConsumer> RecordedAST::record() {
 
   return std::make_unique<Recorder>(this);
 }
 
 std::unique_ptr<PPCallbacks> RecordedPP::record(const Preprocessor &PP) {
   return std::make_unique<PPRecorder>(*this, PP);
 }
 
+void RecordedNoIncludes::record(const CompilerInstance &Clang) {
+  // Derived from PPCallbacks as we want to make Clang take the ownership of
+  // collector.
+  class NoIncludePragmaCollector : public CommentHandler, public PPCallbacks {
+  public:
+    NoIncludePragmaCollector(const CompilerInstance &Clang,
+                             RecordedNoIncludes &Out)
+        : SM(Clang.getSourceManager()), Out(Out) {}
+    bool HandleComment(Preprocessor &PP, SourceRange Range) override {
+      bool InMainFile = SM.isInMainFile(Range.getBegin());
+      auto Pragma =
+          tooling::parseIWYUPragma(SM.getCharacterData(Range.getBegin()));
+      if (!Pragma)
+        return false;
+
+      // Record no_include pragma. We only care about main files.
+      if (InMainFile && Pragma->consume_front("no_include")) {
+        auto Spelling =
+            Pragma->take_until([](char C) { return C == '\n'; }).trim();
+        if (Spelling.empty())
+          return false;
+        const auto SplitQuotedIncludeHeaders = [](llvm::StringRef Buffer) {
+          llvm::SmallVector<llvm::StringRef> Ret;
+          for (size_t Pos = 0, Last = 0; Pos != Buffer.size();) {
+            char Closing = 0;
+            switch (Buffer[Pos]) {
+            case '<':
+              Last = Pos;
+              Closing = '>';
+              break;
+            case '"':
+              Last = Pos++;
+              Closing = '"';
+              break;
+            default:
+              // Ignore non-quoted string
+              ++Pos;
+              continue;
+            }
+            while (Pos != Buffer.size() && Buffer[Pos] != Closing)
+              ++Pos;
+            if (Pos == Buffer.size())
+              break;
+            Ret.emplace_back(Buffer.substr(Last, Pos - Last + 1));
+            ++Pos;
+          }
+          return Ret;
+        };
+        const auto Headers = SplitQuotedIncludeHeaders(Spelling);
+        // Should we support multiple headers on one pragma? Or emit a warning?
+        if (Headers.size() != 1)
+          return false;
+        Spelling = Headers[0];
+        unsigned Offset = SM.getFileOffset(Range.getBegin());
+        unsigned CurrentLine =
+            SM.getLineNumber(SM.getMainFileID(), Offset) - 1; // 0-based.
+        if (const auto Header = Spelling.trim("\"<>"); !Header.empty()) {
+          const auto FE = PP.LookupFile(
+              /*FilenameLoc=*/{}, /*Filename=*/Header,
+              /*isAngled=*/Spelling.starts_with("<"),
+              /*FromDir=*/nullptr, /*FromFile=*/nullptr,
+              /*CurDir=*/nullptr, /*SearchPath=*/nullptr,
+              /*RelativePath=*/nullptr,
+              /*SuggestedModule=*/nullptr, /*IsMapped=*/nullptr,
+              /*IsFrameworkFound=*/nullptr, /*SkipCache=*/false,
+              /*OpenFile=*/false, /*CacheFailures=*/false);
+          if (!FE)
+            return false;
+          Out.IwyuNoIncludes.insert(IwyuNoInclude(
+              /*Written=*/Spelling.str(),
+              /*Resolved=*/
+              FE->getFileEntry().tryGetRealPathName().str(), CurrentLine));
+        }
+        return false;
+      }
+      return false;
+    }
+
+  private:
+    SourceManager &SM;
+    RecordedNoIncludes &Out;
+  };
+  auto Handler = std::make_unique<NoIncludePragmaCollector>(Clang, *this);
+  Clang.getPreprocessor().addCommentHandler(Handler.get());
+  Clang.getPreprocessor().addPPCallbacks(std::move(Handler));
+}
+
 } // namespace clang::include_cleaner

clang-tools-extra/include-cleaner/unittests/RecordTest.cpp

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Testing/Annotations/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang::include_cleaner {
 namespace {
+using testing::AllOf;
 using testing::ElementsAreArray;
 using testing::IsEmpty;
+using testing::UnorderedElementsAre;
 
 // Matches a Decl* if it is a NamedDecl with the given name.
 MATCHER_P(named, N, "") {
   if (const NamedDecl *ND = llvm::dyn_cast<NamedDecl>(arg)) {
     if (N == ND->getNameAsString())
       return true;
   }
   std::string S;
TEST_F(RecordPPTest, CapturesConditionalMacroRefs) {
   EXPECT_THAT(RefOffsets, ElementsAreArray(MainFile.points()));
 }
 
 class PragmaIncludeTest : public ::testing::Test {
 protected:
   // We don't build an AST, we just run a preprocessor action!
   TestInputs Inputs;
   PragmaIncludes PI;
+  RecordedNoIncludes NI;
 
   PragmaIncludeTest() {
     Inputs.MakeAction = [this] {
       struct Hook : public PreprocessOnlyAction {
       public:
-        Hook(PragmaIncludes *Out) : Out(Out) {}
+        Hook(PragmaIncludes *Out, RecordedNoIncludes *NoInc)
+            : Out(Out), NoInc(NoInc) {}
         bool BeginSourceFileAction(clang::CompilerInstance &CI) override {
           Out->record(CI);
+          NoInc->record(CI);
           return true;
         }
         PragmaIncludes *Out;
+        RecordedNoIncludes *NoInc;
       };
-      return std::make_unique<Hook>(&PI);
+      return std::make_unique<Hook>(&PI, &NI);
     };
   }
 
   TestAST build() { return TestAST(Inputs); }
 
   void createEmptyFiles(llvm::ArrayRef<StringRef> FileNames) {
     for (llvm::StringRef File : FileNames)
       Inputs.ExtraFiles[File] = "";
EXPECT_THAT(PI.getExporters(FM.getFile("private2.h").get(), FM),
               testing::UnorderedElementsAre(FileNamed("export1.h")));
   EXPECT_THAT(PI.getExporters(FM.getFile("private3.h").get(), FM),
               testing::UnorderedElementsAre(FileNamed("export1.h")));
 
   EXPECT_TRUE(PI.getExporters(FM.getFile("foo.h").get(), FM).empty());
   EXPECT_TRUE(PI.getExporters(FM.getFile("bar.h").get(), FM).empty());
 }
 
+MATCHER_P(written, Name, "") { return arg.Written == Name; }
+MATCHER_P(includeLine, N, "") { return arg.HashLine == N; }
+MATCHER_P(resolved, Name, "") { return arg.Resolved == Name; }
+
+TEST_F(PragmaIncludeTest, IWYUNoInclude) {
+  Inputs.Code = R"cpp(
+    // IWYU pragma: no_include "baz.h"
+    #include "external.h"
+    #include "foo.h"
+    // IWYU pragma: no_include <bar.h>
+    // IWYU pragma: no_include <multiple> "headers.hpp" are not <valid>
+    // IWYU pragma: no_include <multiple> "headers.hpp" <invalid>
+    // IWYU pragma: no_include "multiple" <headers.hpp> "invalid"
+    // IWYU pragma: no_include no_quotes are considered invalid
+    // IWYU pragma: no_include <valid> texts after are ignored
+    // IWYU pragma: no_include not starting with quotes <are> "ignored"
+  )cpp";
+  Inputs.ExtraFiles["external.h"] = R"cpp(
+    #pragma once
+    // IWYU pragma: no_include <headers.hpp>
+  )cpp";
+  Inputs.ExtraArgs.emplace_back("-I.");
+  createEmptyFiles({"foo.h", "bar.h", "baz.h", "valid", "invalid", "multiple",
+                    "are", "ignored", "headers.hpp"});
+  TestAST Processed = build();
+  auto &NoIncludes = NI.IwyuNoIncludes;
+  EXPECT_THAT(
+      NoIncludes,
+      UnorderedElementsAre(
+          AllOf(written("\"baz.h\""), resolved("baz.h"), includeLine(1)),
+          AllOf(written("<bar.h>"), resolved("bar.h"), includeLine(4)),
+          AllOf(written("<valid>"), resolved("valid"), includeLine(9))));
+}
+
 TEST_F(PragmaIncludeTest, SelfContained) {
   Inputs.Code = R"cpp(
   #include "guarded.h"
 
   #include "unguarded.h"
   )cpp";
   Inputs.ExtraFiles["guarded.h"] = R"cpp(
   #pragma once