[clang-tidy] Implement an include-cleaner check.

[Eugene.Zelenko]

clang-tools-extra/test/clang-tidy/checkers/google/Inputs/bar.h

5 ↗

(On Diff #515323)

Please add. Same in other files.

[carlosgalvezp]

I believe this should be discussed in an RFC. We already have the standalone include-cleaner tool, why is that not sufficient? Can it be extended instead? There's also the include-what-you-use tool out there.

[Eugene.Zelenko]

In D148793#4283733, @carlosgalvezp wrote:

I believe this should be discussed in an RFC. We already have the standalone include-cleaner tool, why is that not sufficient? Can it be extended instead? There's also the include-what-you-use tool out there.

On my understanding, include-cleaner is re-implementation of IWYU. Awhile ago IWYU maintainers tried to merge their project to LLVM. Discussion should be in old mailing lists.

[kadircet]

Hi folks, the rationale for a clang-tidy check is enabling include-cleaner findings to be applied at scale and integrations into existing workflows (e.g. a lot of people run cleanups using clang-tidy findings hence there's somewhat existing infra for that).

current include-cleaner tool has some downsides when it comes to cleaning-up a whole codebase (e.g. it applies changes as it goes, which might result in breaking builds as it goes if not applied carefully), surely these shortcomings can be addressed by introducing more logic into the standalone tool, but it'd still lack the ecosystem & integrations clang-tidy has, which would be really unfortunate.
Could you give some details about how you're using the existing include-cleaner tool so that we better understand use cases around that one too?

As for the existing IWYU tool, include-cleaner library used in this check has a different interpretation of "use", so despite looking similar they have different implementations and might even disagree at certain cases due to these differences.

[VitaNuo]

Move the check from "google" to "misc".

[kadircet]

thanks, mostly LG at the high level i think one thing we're missing is the ability to suppress analysis for certain headers, similar to what we have in clangd config options. can you add a check option for that?

clang-tools-extra/clang-tidy/CMakeLists.txt

10 ↗

(On Diff #520307)

can you move this into clang-tools-extra/clang-tidy/misc/CMakeLists.txt ? in theory it isn't needed by all the checks

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

50

rather than storing state in ::check and running logic in ::onEndOfTranslationUnit, you can just trigger analysis & finding generation here as we already match only on the translation unit decl.

58

TUDecl can have children that are not part of the main file and we'll just run analysis on these decls for nothing as we discard references spelled outside mainfile inside walkUsed.

so can you go over the children of TUDecl, and only pick the ones that are spelled inside the mainfile and feed them as analysis roots?

94

you can use ClangTidyCheck::getCurrentMainFile() instead of Mainfile->tryGetRealPathName()

105

you can have: diag(Inc->HashLocation, "unused include %0") << Inc->quote() << FixItHint::CreateRemoval(..) instead of the string concat above.
(also convention is to have diagnostic messages that start with lower case letters)

107–110

you can use tooling::HeaderIncludes not only for insertions, but also for removals.

114

again you can use ClangTidyCheck::getCurrentMainFile()

115

nit: i'd extract SM->getBufferData(SM->getMainFileID()) into a llvm::StringRef Code and use it in both places

117

no need for braces

124–125

again you can use ClangTidyCheck::getCurrentMainFile() and drop the check

126

constructor of tooling::HeaderIncludes parses the code, so let's create it once outside the loop?

140

you can use the substitution alternative mentioned above here as well

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.h

26

can you move this struct into the implementation file? as it isn't exposed in the interfaces

clang-tools-extra/docs/ReleaseNotes.rst

200

Enforces include-what-you-use on headers using include-cleaner. ?

clang-tools-extra/docs/clang-tidy/checks/list.rst

296

could you revert this change?

485

could you revert this change?

clang-tools-extra/docs/clang-tidy/checks/misc/include-cleaner.rst

7

can you also mention that this only generates findings for the main file of a translation unit?

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

152–153

can you change this constructor to : RecordPragma(CI.getSourceManager(), CI.getPreprocessor(), Out) ?

158

no need to pass SM seperately, you can get it out of pre-processor via PP.getSourceManager()

348

same here, no need to pass SM separately

[VitaNuo]

Address review comments.

[kadircet]

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

62

after storing them in the class state on construction, we should provide them with current values here:

/// Should store all options supported by this check with their
/// current values or default values for options that haven't been overridden.

67

as mentioned above, rather than doing this on demand, we should run the logic on construction and store in the class state

67

s/Suppress/IgnoreHeader

to be consistent with option in clangd

82

we should actually use FileLoc of the decl location here (i.e. map it back to spelling location) as the decl might be introduced by a macro expansion, but if the spelling of "primary" location belongs to the main file we should still analyze it (e.g. decls introduced via TEST macros)

also SourceManager::isInMainFile will follow #line directives, which can create confusion (a declaration from some other file will create a diagnostic in the main file), so let's use isWrittenInMainFile instead?

102

we should also respect IgnoreHeaders here

127

sorry i guess i wasn't explicit about this one, but it should actually be a suffix match based regex (e.g. foo/.* disables analysis for all sources under a directory called foo) on the resolved path of the include (similar to what we do in clangd).

as headers can be spelled differently based on the translation unit and this option is mentioned for the whole codebase.

132

FileData makes it sound like this is some other data about the file rather than its contents. maybe just Code?

145

sorry I know I suggested using HeaderIncludes for removals too, but this seems to cause more trouble actually;

we should actually go over rest of the replacements too, HeaderIncludes will generate removals for all the includes that match this (spelling, quoting). hence we can't just apply the first removal.
but that'll imply we'll remove them multiple times (as analysis above will treat each of them as a separate unused include). hence we'll need some deduplicaiton.

it might be easier to just use line number we have in Inc and use SourceManager:: translateFileLineCol to drop the whole line (up until start of the next line).

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.h

44

the convention is to rather store options in check's state on construction. see documentation on ClangTidyCheck::ClangTidyCheck:

/// Initializes the check with \p CheckName and \p Context.
///
/// Derived classes must implement the constructor with this signature or
/// delegate it. If a check needs to read options, it can do this in the
/// constructor using the Options.get() methods below.

clang-tools-extra/docs/clang-tidy/checks/misc/include-cleaner.rst

9

can you also mention the check options for ignoring analysis?

clang-tools-extra/unittests/clang-tidy/IncludeCleanerTest.cpp

19

can you have the includes multiple times and make sure all of them are being dropped?

38

can you also test for insertion suppressions ?

[sammccall]

Drive-by nit: want add this to the disableUnusableChecks() blocklist in clangd/TidyProvider.cpp?
Since inside clangd we want to use the direct feature instead.

[VitaNuo]

Rework according to the review comments.

[kadircet]

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

43

let's put this struct into anon namespace

49

in theory this is not enough to disable the check for objc++, it'll have both objc and cplusplus set. so we should check ObjC is false (there's no need to disable it for c, right?)

nit: we can also override isLanguageVersionSupported to disable check for non-c++.

68

let's make sure we're only going to match suffixes by appending $ to the Header here.

also before pushing into IgnoreHeadersRegex can you verify the regex isValid and report a diagnostic via configurationDiag if regex is invalid.

73

check is performed only once for this check so it doesn't matter, but it might be better to perform this in constructor and store as class state to make sure we're only parsing options and creating the regexes once (also possibly reporting diagnostics once). as regex creation is actually expensive

84

instead of const_cast here, you can just drop the const in const auto *D in for loop variable

108

we're running this against spelled include of the file, not resolved path.

we should instead use the spelling + trimmed version for verbatim/standard headers and use FileEntry::tryGetRealPathName for phyiscal headers. we can even do the filtering before spelling the header to not spell redundantly.

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.h

49

let's make a full copy here and store a std::string instead, as reference from options might become dangling. also the copy is cheap, we do that once per check instantiation.

clang-tools-extra/docs/clang-tidy/checks/misc/include-cleaner.rst

16

[VitaNuo]

Thanks for the comments! I'll re-assign the review to Haojian for now, so that we can hopefully make more progress this week.

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

49

Ah thanks for the tip with isLanguageVersionSupported, doing that now.

68

Thanks, good ideas!

clang-tools-extra/docs/clang-tidy/checks/misc/include-cleaner.rst

16

You probably wanted to say insertion/removal instead of inclusion/insertion.

[VitaNuo]

Address review comments.

[PiotrZSL]

Not too bad, you on a right road. Tests failed on windows, and clang-format failed.

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

87

auto -> const Decl*

171–176

Use IncludeInserter::createIncludeInsertion if possible...
So include style would be properly handled.

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.h

29–30

this description does not match first sentence in check documentation.

43

many check uses ; as separator, and uses parseStringList function to do that from OptionsUtils.

45

if someone will put empty string like this ,, you will end up with $ as regex, wont it match "everything" ?

48

llvm::Regex got constructor, use emplace_back

56

Missing "void storeOptions(ClangTidyOptions::OptionMap &Opts) override;"
to store IgnoreHeaders option. --export-config may not work correctly without this.

clang-tools-extra/docs/ReleaseNotes.rst

200

is this actually a "include-what-you-use" ?
Simply if I use iwyu tool, will it give same output and result in same behaviour ?
If this is different tool, then change this to avoid confusion.

200

This description does not match first sentence in check documentation.

clang-tools-extra/docs/clang-tidy/checks/misc/include-cleaner.rst

7

avoid "The check"

10

Try adding some very simple "example"

18

add some info about default value, is there any ?

clang-tools-extra/unittests/clang-tidy/IncludeCleanerTest.cpp

10

this test file is fine, but there is no validation of output warning.

[PiotrZSL]

clang-tools-extra/unittests/clang-tidy/IncludeCleanerTest.cpp

10

nwm, somehow I missed one file.

20

make sure that those tests does not depend on actual system headers (check what headers are included here).

[hokein]

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

46

storing a string instance for header per system reference is expensive (we might have many missing-include symbols, and we might have many duplications). We can store the a clang::include_cleaner::Header in the struct here, and call the spellHeader when generating the FixIts.

89

We should use the getExpansionLoc rather than the SpellingLoc here, otherwise we might miss the case like TEST_F(WalkUsedTest, MultipleProviders) {... } where the decl location is spelled in another file, but the function body is spelled in main-file.

90

and we probably need the same logic to filtering out implicit template specialization, similar to https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/include-cleaner/lib/Record.cpp#L408-L410.

It is fine to leave it in this patch, but please add a FIXME.

131

nit: the prefix ClangTidyCheck:: qualifier is not needed, you can remove it.

150

The diagnostic message "unused include ..." seems too short for users to understand what's the issue here, it would be better to make it more descriptive, in clangd, we emit included header ... is not used directly, we can follow this pattern.

The same for the missing-includes.

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.h

37

nit: the function body is long, consider moving it to .cpp file.

clang-tools-extra/clangd/TidyProvider.cpp

220

nit: the entry here is under the Crashing Checks category, this doesn't seem a good fit. Maybe move it right after the above empty string "".

clang-tools-extra/docs/clang-tidy/checks/misc/include-cleaner.rst

14

IgnoreHeader => IgnoreHeaders, in the implementation, we use the plural form.

[hokein]

clang-tools-extra/unittests/clang-tidy/IncludeCleanerTest.cpp

2

nit: missing the license file comment.

[hokein]

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

171–176

tooling::HeaderIncludes already handles the include style well (and more). In general, we recommend to use tooling::headerIncludes -- it was built for generic toolings that need to perform #include manipulations, it has been heavily used in clangd/clang-format/clang-include-cleaner etc.

IncludeInserter::createIncludeInsertion is an old implementation in clang-tidy, and it was built before tooling::HeaderIncludes is thing. In the long-term, I think we should probably consider deprecating it and replacing it with tooling::HeaderIncludes.

[VitaNuo]

Address review comments.

[VitaNuo]

Thanks for the comments!

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

82

we should actually use FileLoc of the decl location here (i.e. map it back to spelling location) as the decl might be introduced by a macro expansion, but if the spelling of "primary" location belongs to the main file we should still analyze it (e.g. decls introduced via TEST macros)

also SourceManager::isInMainFile will follow #line directives, which can create confusion (a declaration from some other file will create a diagnostic in the main file), so let's use isWrittenInMainFile instead?

87

const will not work, since the container I need to populate has to have llvm::SmallVector<Decl *> type due to the include-cleaner library interfaces.

89

we should actually use FileLoc of the decl location here (i.e. map it back to spelling location) as the decl might be introduced by a macro expansion, but if the spelling of "primary" location belongs to the main file we should still analyze it (e.g. decls introduced via TEST macros)

we actually want spelling location, not fileloc
sorry for the confusion
basically, spelling location will always map to where a name is spelled in a > physical file, even if it's part of macro body
whereas getFileLoc, will map tokens from macro body to their expansion locations (i.e. place in a physical file where the macro is invoked)

These are earlier comments from Kadir on this topic. AFAIU we want the spelling location for TEST_F(WalkUsedTest, MultipleProviders) {... } because:

• for Decls introduced by the TEST_F expansion, we would like to analyze them only if they are spelled in the main file.
• for arguments, their transitive spelling location is where they're written. So if TEST_F(WalkUsedTest, MultipleProviders) {... } is written in the main file, the argument locations will be counted.

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.h

43

Thanks for the tip, I can use the OptionsUtils infrastructure indeed.

clang-tools-extra/unittests/clang-tidy/IncludeCleanerTest.cpp

20

they don't, adding a declaration to the custom "vector.h" and then using it in the main file makes vector disappear from the list of unused includes.
On top of that, even if the test did somehow depend on the actual system headers, this wouldn't change anything in the test result, since the vector header would remain unused.

[Eugene.Zelenko]

clang-tools-extra/docs/ReleaseNotes.rst

197

Please keep alphabetical order (by check name) in this section.

200

One sentence is enough.

[hokein]

The only thing is the source location, see my comments for details, otherwise looks good in general.

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

89

I think I'm not convinced, see my comments below.

for Decls introduced by the TEST_F expansion, we would like to analyze them only if they are spelled in the main file.

I think it is true for some cases. For example, a function decl has different parts (declarator, and function body), if the declarator is introduced by a macro which defined in a header, and the function body is spelled in the main-file, we still want to analyze the function body, see a simple example below:

// foo.h
#define DECLARE(X) void X()

// main.cpp
#include "foo.h"

DECLARE(myfunc) {
   int a;
   ...
}

Moreover, we have use ExpansionLoc pattern in other places when we collect the main-file top-level decl (include-cleaner, clangd), and I don't see a special reason to change the pattern in the clang-tidy check.

117

it is sad that we duplicate the include-cleaner analyse implementation (the only difference is that here we record the references for missing-includes), I think we should find a way to share the code in the future.

No action required in this patch, can you add a FIXME?

195

I think we should use the spelling location -- Inc.SymRefLocation can be a macro location which can points to another file, we intend to show diagnostics for main-file only, and walkUsed has some internal logic which guarantees that the spelling loc of returned refs is main-file.

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.h

22

can you cleanup the includes here? looks like there are some unused-includes now, at least Syntax/Tokens.h from the first glance.

clang-tools-extra/docs/clang-tidy/checks/misc/include-cleaner.rst

5

nit: remove extra trailing ==

clang-tools-extra/unittests/clang-tidy/IncludeCleanerTest.cpp

2

nit: IncludeCleanerTest.cpp

[VitaNuo]

Update release notes.

[VitaNuo]

Address review comments.

[VitaNuo]

Thanks for the comments!

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

89

Is the expansion location of myfunc in the main file? If that's the case, we need the expansion location indeed.
Otherwise, we need getFileLoc to map file locations from macro arguments to their spelling (in the main file above) and locations from macro bodies to the expansion location.

[hokein]

Thanks, just a few nits. I think it is in a good shape, let's ship it!

Please make sure the premerge-test is happy before landing the patch, the windows premerge test is failing now (https://buildkite.com/llvm-project/premerge-checks/builds/155660#0188764d-dc9f-4e8f-b489-c7b8f8b0c52a)

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

89

Is the expansion location of myfunc in the main file? If that's the case, we need the expansion location indeed.

Right. The expansion location here is a file location which points to the main-file.

Would be nice if you add the above test into the unittest.

190–194

nit: we can simplify it like

if (auto Replacement = HeaderIncludes.insert(...))
   diag(...);

clang-tools-extra/unittests/clang-tidy/IncludeCleanerTest.cpp

28

wrap all things into an anonymous namespace to avoid potential ODR violations.

71

Instead of using 4 += statements, I think it is a bit clearer to use llvm::formatv("bar.h;{1};{2};...", appendPathSystemIndependent(...), ....);

[VitaNuo]

Try to fix windows test.

[VitaNuo]

Remove system-independent handling to see behavior on Windows.

[VitaNuo]

Remove the regular expression.

[VitaNuo]

Remove regex and path handling.

[VitaNuo]

Remove regex and path handling.

[VitaNuo]

Add debug statements for windows debugging.

[VitaNuo]

Remove debug statements.

[VitaNuo]

Re-introduce special path handling.

[VitaNuo]

Try to fix windows build.

[VitaNuo]

Try ignoring verbatim spelling.

[VitaNuo]

Fix last test.

[VitaNuo]

Undo.

[VitaNuo]

Experiment with paths.

[VitaNuo]

Undo.

[VitaNuo]

Escape the slashes in regex.

[VitaNuo]

Remove path handling.

[VitaNuo]

Re-introduce path handling.

[mgorny]

I'm getting completely incomprehensible build errors on Gentoo from this, as of aa7eace8431ba213c5431638b894b0e1b4b481c7:

samu: job failed: : && /usr/lib/ccache/bin/x86_64-pc-linux-gnu-g++ -march=znver2 --param=l1-cache-size=32 --param=l1-cache-line-size=64 -O2 -pipe -frecord-gcc-switches -fPIC -fno-semantic-interposition -fvisibility-inlines-hidden -Werror=date-time -fno-lifetime-dse -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -Wimplicit-fallthrough -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wdelete-non-virtual-dtor -Wsuggest-override -Wno-comment -Wno-misleading-indentation -Wctad-maybe-unsupported -fdiagnostics-color -ffunction-sections -fdata-sections -fno-common -Woverloaded-virtual -fno-strict-aliasing -pedantic -Wno-long-long -Wl,-O1 -Wl,--as-needed -Wl,--hash-style=gnu   -Wl,--export-dynamic -rdynamic  -Wl,-rpath-link,/var/tmp/portage/sys-devel/clang-17.0.0_pre20230603/work/x/y/clang-abi_x86_64.amd64/./lib64 tools/extra/clang-tidy/tool/CMakeFiles/clang-tidy.dir/ClangTidyToolMain.cpp.o -o bin/clang-tidy -L/usr/lib/llvm/17/lib64 -Wl,-rpath,"\$ORIGIN/../lib64:/usr/lib/llvm/17/lib64:/var/tmp/portage/sys-devel/clang-17.0.0_pre20230603/work/x/y/clang-abi_x86_64.amd64/lib64:"  lib64/libclangTidy.a  lib64/libclangTidyMain.a  lib64/libclangTidyAndroidModule.a  lib64/libclangTidyAbseilModule.a  lib64/libclangTidyAlteraModule.a  lib64/libclangTidyBoostModule.a  lib64/libclangTidyBugproneModule.a  lib64/libclangTidyCERTModule.a  lib64/libclangTidyConcurrencyModule.a  lib64/libclangTidyCppCoreGuidelinesModule.a  lib64/libclangTidyDarwinModule.a  lib64/libclangTidyFuchsiaModule.a  lib64/libclangTidyGoogleModule.a  lib64/libclangTidyHICPPModule.a  lib64/libclangTidyLinuxKernelModule.a  lib64/libclangTidyLLVMModule.a  lib64/libclangTidyLLVMLibcModule.a  lib64/libclangTidyMiscModule.a  lib64/libclangTidyModernizeModule.a  lib64/libclangTidyObjCModule.a  lib64/libclangTidyOpenMPModule.a  lib64/libclangTidyPerformanceModule.a  lib64/libclangTidyPortabilityModule.a  lib64/libclangTidyReadabilityModule.a  lib64/libclangTidyZirconModule.a  lib64/libclangTidyMPIModule.a  lib64/libclangTidyBugproneModule.a  lib64/libclangTidyCppCoreGuidelinesModule.a  lib64/libclangTidyGoogleModule.a  lib64/libclangTidyMiscModule.a  lib64/libclangAnalysis.a  lib64/libclangASTMatchers.a  lib64/libclangAST.a  lib64/libclangLex.a  lib64/libclangBasic.a  lib64/libclangTidyModernizeModule.a  lib64/libclangTidyReadabilityModule.a  lib64/libclangTidyUtils.a  lib64/libclangTidy.a  lib64/libclang-cpp.so.17gitaa7eace8  /usr/lib/llvm/17/lib64/libLLVM-17gitaa7eace8.so && :
/usr/lib/gcc/x86_64-pc-linux-gnu/13/../../../../x86_64-pc-linux-gnu/bin/ld: lib64/libclangTidyMiscModule.a(IncludeCleanerCheck.cpp.o): in function `clang::tidy::misc::IncludeCleanerCheck::registerPPCallbacks(clang::SourceManager const&, clang::Preprocessor*, clang::Preprocessor*) [clone .localalias]':
IncludeCleanerCheck.cpp:(.text._ZN5clang4tidy4misc19IncludeCleanerCheck19registerPPCallbacksERKNS_13SourceManagerEPNS_12PreprocessorES7_+0x24): undefined reference to `clang::include_cleaner::RecordedPP::record(clang::Preprocessor const&)'
/usr/lib/gcc/x86_64-pc-linux-gnu/13/../../../../x86_64-pc-linux-gnu/bin/ld: IncludeCleanerCheck.cpp:(.text._ZN5clang4tidy4misc19IncludeCleanerCheck19registerPPCallbacksERKNS_13SourceManagerEPNS_12PreprocessorES7_+0x94): undefined reference to `clang::include_cleaner::PragmaIncludes::record(clang::Preprocessor&)'
/usr/lib/gcc/x86_64-pc-linux-gnu/13/../../../../x86_64-pc-linux-gnu/bin/ld: lib64/libclangTidyMiscModule.a(IncludeCleanerCheck.cpp.o): in function `clang::tidy::misc::IncludeCleanerCheck::check(clang::ast_matchers::MatchFinder::MatchResult const&) [clone .localalias]':
IncludeCleanerCheck.cpp:(.text._ZN5clang4tidy4misc19IncludeCleanerCheck5checkERKNS_12ast_matchers11MatchFinder11MatchResultE+0x508): undefined reference to `clang::include_cleaner::walkUsed(llvm::ArrayRef<clang::Decl*>, llvm::ArrayRef<clang::include_cleaner::SymbolReference>, clang::include_cleaner::PragmaIncludes const*, clang::SourceManager const&, llvm::function_ref<void (clang::include_cleaner::SymbolReference const&, llvm::ArrayRef<clang::include_cleaner::Header>)>)'
/usr/lib/gcc/x86_64-pc-linux-gnu/13/../../../../x86_64-pc-linux-gnu/bin/ld: IncludeCleanerCheck.cpp:(.text._ZN5clang4tidy4misc19IncludeCleanerCheck5checkERKNS_12ast_matchers11MatchFinder11MatchResultE+0x604): undefined reference to `clang::include_cleaner::PragmaIncludes::getPublic(clang::FileEntry const*) const'
/usr/lib/gcc/x86_64-pc-linux-gnu/13/../../../../x86_64-pc-linux-gnu/bin/ld: IncludeCleanerCheck.cpp:(.text._ZN5clang4tidy4misc19IncludeCleanerCheck5checkERKNS_12ast_matchers11MatchFinder11MatchResultE+0x9e8): undefined reference to `clang::include_cleaner::Include::quote[abi:cxx11]() const'
/usr/lib/gcc/x86_64-pc-linux-gnu/13/../../../../x86_64-pc-linux-gnu/bin/ld: IncludeCleanerCheck.cpp:(.text._ZN5clang4tidy4misc19IncludeCleanerCheck5checkERKNS_12ast_matchers11MatchFinder11MatchResultE+0xd15): undefined reference to `clang::include_cleaner::spellHeader[abi:cxx11](clang::include_cleaner::Header const&, clang::HeaderSearch const&, clang::FileEntry const*)'
/usr/lib/gcc/x86_64-pc-linux-gnu/13/../../../../x86_64-pc-linux-gnu/bin/ld: lib64/libclangTidyMiscModule.a(IncludeCleanerCheck.cpp.o): in function `void llvm::function_ref<void (clang::include_cleaner::SymbolReference const&, llvm::ArrayRef<clang::include_cleaner::Header>)>::callback_fn<clang::tidy::misc::IncludeCleanerCheck::check(clang::ast_matchers::MatchFinder::MatchResult const&)::{lambda(clang::include_cleaner::SymbolReference const&, llvm::ArrayRef<clang::include_cleaner::Header>)#1}>(long, clang::include_cleaner::SymbolReference const&, llvm::ArrayRef<clang::include_cleaner::Header>)':
IncludeCleanerCheck.cpp:(.text._ZN4llvm12function_refIFvRKN5clang15include_cleaner15SymbolReferenceENS_8ArrayRefINS2_6HeaderEEEEE11callback_fnIZNS1_4tidy4misc19IncludeCleanerCheck5checkERKNS1_12ast_matchers11MatchFinder11MatchResultEEUlS5_S8_E_EEvlS5_S8_+0xd1): undefined reference to `clang::include_cleaner::Includes::match(clang::include_cleaner::Header) const'
collect2: error: ld returned 1 exit status

[mstorsjo]

In D148793#4392788, @mgorny wrote:

I'm getting completely incomprehensible build errors on Gentoo from this

I'm also hitting this; it only seems to happen if building with -DLLVM_LINK_LLVM_DYLIB=ON.

[mgorny]

My educated guess would be that clangIncludeCleaner is being linked via clang_target_link_libraries while it's not part of libclang-cpp, so it should go into regular target_link_libraries.

[mstorsjo]

In D148793#4393385, @mgorny wrote:

My educated guess would be that clangIncludeCleaner is being linked via clang_target_link_libraries while it's not part of libclang-cpp, so it should go into regular target_link_libraries.

Yes, that does seem to do the trick. LGTM from my PoV if you can push such a fix, otherwise I can try to do it in a little while...

[hokein]

In D148793#4393386, @mstorsjo wrote:

In D148793#4393385, @mgorny wrote:

My educated guess would be that clangIncludeCleaner is being linked via clang_target_link_libraries while it's not part of libclang-cpp, so it should go into regular target_link_libraries.

Yes, that does seem to do the trick. LGTM from my PoV if you can push such a fix, otherwise I can try to do it in a little while...

Looks like it is fixed in https://github.com/llvm/llvm-project/commit/ac0ea7555ee4ae872bcd153e04513ba0b88b8985, thanks!

clang-tools-extra/clang-tidy/misc/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   )
 
 setup_host_tool(clang-tidy-confusable-chars-gen CLANG_TIDY_CONFUSABLE_CHARS_GEN clang_tidy_confusable_chars_gen clang_tidy_confusable_chars_gen_target)
 
 add_subdirectory(ConfusableTable)
 
+include_directories(BEFORE "${CMAKE_CURRENT_SOURCE_DIR}/../../include-cleaner/include")
 
 add_custom_command(
     OUTPUT Confusables.inc
     COMMAND ${clang_tidy_confusable_chars_gen} ${CMAKE_CURRENT_SOURCE_DIR}/ConfusableTable/confusables.txt ${CMAKE_CURRENT_BINARY_DIR}/Confusables.inc
     DEPENDS ${clang_tidy_confusable_chars_gen_target} ConfusableTable/confusables.txt)
 
 add_custom_target(genconfusable DEPENDS Confusables.inc)
 
 add_clang_library(clangTidyMiscModule
   ConstCorrectnessCheck.cpp
   DefinitionsInHeadersCheck.cpp
   ConfusableIdentifierCheck.cpp
+  IncludeCleanerCheck.cpp
   MiscTidyModule.cpp
   MisleadingBidirectional.cpp
   MisleadingIdentifier.cpp
   MisplacedConstCheck.cpp
   NewDeleteOverloadsCheck.cpp
   NoRecursionCheck.cpp
   NonCopyableObjects.cpp
   NonPrivateMemberVariablesInClassesCheck.cpp
add_clang_library(clangTidyMiscModule
   )
 
 clang_target_link_libraries(clangTidyMiscModule
   PRIVATE
   clangAnalysis
   clangAST
   clangASTMatchers
   clangBasic
+  clangIncludeCleaner
   clangLex
   clangSerialization
   clangTooling
   )

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.h

+//===--- IncludeCleanerCheck.h - clang-tidy ---------------------*- 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_CLANG_TIDY_MISC_INCLUDECLEANER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCLUDECLEANER_H
+
+#include "../ClangTidyCheck.h"
+#include "../ClangTidyDiagnosticConsumer.h"
+#include "../ClangTidyOptions.h"
+#include "clang-include-cleaner/Record.h"
+#include "clang-include-cleaner/Types.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Lex/HeaderSearch.h"
+#include "llvm/Support/Regex.h"
+#include <vector>
+
+namespace clang::tidy::misc {
+
+/// Checks for unused and missing includes. Generates findings only for
+/// the main file of a translation unit.
+/// Findings correspond to https://clangd.llvm.org/design/include-cleaner.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/misc/include-cleaner.html
+class IncludeCleanerCheck : public ClangTidyCheck {
+public:
+  IncludeCleanerCheck(StringRef Name, ClangTidyContext *Context);
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
+                           Preprocessor *ModuleExpanderPP) override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override;
+
+private:
+  include_cleaner::RecordedPP RecordedPreprocessor;
+  include_cleaner::PragmaIncludes RecordedPI;
+  HeaderSearch *HS;
+  std::vector<StringRef> IgnoreHeaders;
+  llvm::SmallVector<llvm::Regex> IgnoreHeadersRegex;
+  bool shouldIgnore(const include_cleaner::Header &H);
+};
+
+} // namespace clang::tidy::misc
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCLUDECLEANER_H

clang-tools-extra/clang-tidy/misc/IncludeCleanerCheck.cpp

+//===--- IncludeCleanerCheck.cpp - clang-tidy -----------------------------===//
+//
+// 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 "IncludeCleanerCheck.h"
+#include "../ClangTidyCheck.h"
+#include "../ClangTidyDiagnosticConsumer.h"
+#include "../ClangTidyOptions.h"
+#include "../utils/OptionsUtils.h"
+#include "clang-include-cleaner/Analysis.h"
+#include "clang-include-cleaner/Record.h"
+#include "clang-include-cleaner/Types.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclBase.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/FileEntry.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Format/Format.h"
+#include "clang/Lex/Preprocessor.h"
+#include "clang/Tooling/Core/Replacement.h"
+#include "clang/Tooling/Inclusions/HeaderIncludes.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/Regex.h"
+#include <optional>
+#include <string>
+#include <vector>
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::misc {
+
+namespace {
+struct MissingIncludeInfo {
+  SourceLocation SymRefLocation;
+  include_cleaner::Header Missing;
+};
+} // namespace
+
+IncludeCleanerCheck::IncludeCleanerCheck(StringRef Name,
+                                         ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      IgnoreHeaders(utils::options::parseStringList(
+          Options.getLocalOrGlobal("IgnoreHeaders", ""))) {
+  for (const auto &Header : IgnoreHeaders) {
+    if (!llvm::Regex{Header}.isValid())
+      configurationDiag("Invalid ignore headers regex '%0'") << Header;
+    std::string HeaderSuffix{Header.str()};
+    if (!Header.ends_with("$"))
+      HeaderSuffix += "$";
+    IgnoreHeadersRegex.emplace_back(HeaderSuffix);
+  }
+}
+
+void IncludeCleanerCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "IgnoreHeaders",
+                utils::options::serializeStringList(IgnoreHeaders));
+}
+
+bool IncludeCleanerCheck::isLanguageVersionSupported(
+    const LangOptions &LangOpts) const {
+  return !LangOpts.ObjC;
+}
+
+void IncludeCleanerCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(translationUnitDecl().bind("top"), this);
+}
+
+void IncludeCleanerCheck::registerPPCallbacks(const SourceManager &SM,
+                                              Preprocessor *PP,
+                                              Preprocessor *ModuleExpanderPP) {
+  PP->addPPCallbacks(RecordedPreprocessor.record(*PP));
+  HS = &PP->getHeaderSearchInfo();
+  RecordedPI.record(*PP);
+}
+
+bool IncludeCleanerCheck::shouldIgnore(const include_cleaner::Header &H) {
+  return llvm::any_of(IgnoreHeadersRegex, [&H](const llvm::Regex &R) {
+    switch (H.kind()) {
+    case include_cleaner::Header::Standard:
+      return R.match(H.standard().name());
+    case include_cleaner::Header::Verbatim:
+      return R.match(H.verbatim());
+    case include_cleaner::Header::Physical:
+      return R.match(H.physical()->tryGetRealPathName());
+    }
+    llvm_unreachable("Unknown Header kind.");
+  });
+}
+
+void IncludeCleanerCheck::check(const MatchFinder::MatchResult &Result) {
+  const SourceManager *SM = Result.SourceManager;
+  const FileEntry *MainFile = SM->getFileEntryForID(SM->getMainFileID());
+  llvm::DenseSet<const include_cleaner::Include *> Used;
+  std::vector<MissingIncludeInfo> Missing;
+  llvm::SmallVector<Decl *> MainFileDecls;
+  for (Decl *D : Result.Nodes.getNodeAs<TranslationUnitDecl>("top")->decls()) {
+    if (!SM->isWrittenInMainFile(SM->getExpansionLoc(D->getLocation())))
+      continue;
+    // FIXME: Filter out implicit template specializations.
+    MainFileDecls.push_back(D);
+  }
+  // FIXME: Find a way to have less code duplication between include-cleaner
+  // analysis implementation and the below code.
+  walkUsed(MainFileDecls, RecordedPreprocessor.MacroReferences, &RecordedPI,
+           *SM,
+           [&](const include_cleaner::SymbolReference &Ref,
+               llvm::ArrayRef<include_cleaner::Header> Providers) {
+             bool Satisfied = false;
+             for (const include_cleaner::Header &H : Providers) {
+               if (H.kind() == include_cleaner::Header::Physical &&
+                   H.physical() == MainFile)
+                 Satisfied = true;
+
+               for (const include_cleaner::Include *I :
+                    RecordedPreprocessor.Includes.match(H)) {
+                 Used.insert(I);
+                 Satisfied = true;
+               }
+             }
+             if (!Satisfied && !Providers.empty() &&
+                 Ref.RT == include_cleaner::RefType::Explicit &&
+                 !shouldIgnore(Providers.front()))
+               Missing.push_back({Ref.RefLocation, Providers.front()});
+           });
+
+  std::vector<const include_cleaner::Include *> Unused;
+  for (const include_cleaner::Include &I :
+       RecordedPreprocessor.Includes.all()) {
+    if (Used.contains(&I) || !I.Resolved)
+      continue;
+    if (RecordedPI.shouldKeep(I.Line))
+      continue;
+    // Check if main file is the public interface for a private header. If so
+    // we shouldn't diagnose it as unused.
+    if (auto PHeader = RecordedPI.getPublic(I.Resolved); !PHeader.empty()) {
+      PHeader = PHeader.trim("<>\"");
+      // Since most private -> public mappings happen in a verbatim way, we
+      // check textually here. This might go wrong in presence of symlinks or
+      // header mappings. But that's not different than rest of the places.
+      if (getCurrentMainFile().endswith(PHeader))
+        continue;
+    }
+
+    if (llvm::none_of(IgnoreHeadersRegex,
+                      [Resolved = I.Resolved->tryGetRealPathName()](
+                          const llvm::Regex &R) { return R.match(Resolved); }))
+      Unused.push_back(&I);
+  }
+
+  llvm::StringRef Code = SM->getBufferData(SM->getMainFileID());
+  auto FileStyle =
+      format::getStyle(format::DefaultFormatStyle, getCurrentMainFile(),
+                       format::DefaultFallbackStyle, Code,
+                       &SM->getFileManager().getVirtualFileSystem());
+  if (!FileStyle)
+    FileStyle = format::getLLVMStyle();
+
+  for (const auto *Inc : Unused) {
+    diag(Inc->HashLocation, "included header %0 is not used directly")
+        << Inc->quote()
+        << FixItHint::CreateRemoval(CharSourceRange::getCharRange(
+               SM->translateLineCol(SM->getMainFileID(), Inc->Line, 1),
+               SM->translateLineCol(SM->getMainFileID(), Inc->Line + 1, 1)));
+  }
+
+  tooling::HeaderIncludes HeaderIncludes(getCurrentMainFile(), Code,
+                                         FileStyle->IncludeStyle);
+  for (const auto &Inc : Missing) {
+    std::string Spelling =
+        include_cleaner::spellHeader(Inc.Missing, *HS, MainFile);
+    bool Angled = llvm::StringRef{Spelling}.starts_with("<");
+    // We might suggest insertion of an existing include in edge cases, e.g.,
+    // include is present in a PP-disabled region, or spelling of the header
+    // turns out to be the same as one of the unresolved includes in the
+    // main file.
+    if (auto Replacement =
+            HeaderIncludes.insert(llvm::StringRef{Spelling}.trim("\"<>"),
+                                  Angled, tooling::IncludeDirective::Include))
+      diag(SM->getSpellingLoc(Inc.SymRefLocation),
+           "no header providing %0 is directly included")
+          << Spelling
+          << FixItHint::CreateInsertion(
+                 SM->getComposedLoc(SM->getMainFileID(),
+                                    Replacement->getOffset()),
+                 Replacement->getReplacementText());
+  }
+}
+
+} // namespace clang::tidy::misc

clang-tools-extra/clang-tidy/misc/MiscTidyModule.cpp

 //===--- MiscTidyModule.cpp - clang-tidy ----------------------------------===//
 //
 // 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 "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "ConfusableIdentifierCheck.h"
 #include "ConstCorrectnessCheck.h"
 #include "DefinitionsInHeadersCheck.h"
+#include "IncludeCleanerCheck.h"
 #include "MisleadingBidirectional.h"
 #include "MisleadingIdentifier.h"
 #include "MisplacedConstCheck.h"
 #include "NewDeleteOverloadsCheck.h"
 #include "NoRecursionCheck.h"
 #include "NonCopyableObjects.h"
 #include "NonPrivateMemberVariablesInClassesCheck.h"
 #include "RedundantExpressionCheck.h"

 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<ConfusableIdentifierCheck>(
         "misc-confusable-identifiers");
     CheckFactories.registerCheck<ConstCorrectnessCheck>(
         "misc-const-correctness");
     CheckFactories.registerCheck<DefinitionsInHeadersCheck>(
         "misc-definitions-in-headers");
+    CheckFactories.registerCheck<IncludeCleanerCheck>("misc-include-cleaner");
     CheckFactories.registerCheck<MisleadingBidirectionalCheck>(
         "misc-misleading-bidirectional");
     CheckFactories.registerCheck<MisleadingIdentifierCheck>(
         "misc-misleading-identifier");
     CheckFactories.registerCheck<MisplacedConstCheck>("misc-misplaced-const");
     CheckFactories.registerCheck<NewDeleteOverloadsCheck>(
         "misc-new-delete-overloads");
     CheckFactories.registerCheck<NoRecursionCheck>("misc-no-recursion");

clang-tools-extra/clangd/TidyProvider.cpp

return [Checks = std::string(Checks),
              tidy::ClangTidyOptions &Opts, llvm::StringRef) {
     mergeCheckList(Opts.Checks, Checks);
     mergeCheckList(Opts.WarningsAsErrors, WarningsAsErrors);
   };
 }
 
 TidyProvider disableUnusableChecks(llvm::ArrayRef<std::string> ExtraBadChecks) {
   constexpr llvm::StringLiteral Seperator(",");
-  static const std::string BadChecks =
-      llvm::join_items(Seperator,
-                       // We want this list to start with a seperator to
-                       // simplify appending in the lambda. So including an
-                       // empty string here will force that.
-                       "",
-                       // ----- False Positives -----
+  static const std::string BadChecks = llvm::join_items(
+      Seperator,
+      // include-cleaner is directly integrated in IncludeCleaner.cpp
+      "-misc-include-cleaner",
+
 
-                       // Check relies on seeing ifndef/define/endif directives,
-                       // clangd doesn't replay those when using a preamble.
-                       "-llvm-header-guard", "-modernize-macro-to-enum",
 
-                       // ----- Crashing Checks -----
 
-                       // Check can choke on invalid (intermediate) c++
-                       // code, which is often the case when clangd
-                       // tries to build an AST.
-                       "-bugprone-use-after-move",
-                       // Alias for bugprone-use-after-move.
-                       "-hicpp-invalid-access-moved",
 
-                       // ----- Performance problems -----
 
-                       // This check runs expensive analysis for each variable.
-                       // It has been observed to increase reparse time by 10x.
-                       "-misc-const-correctness");
 
   size_t Size = BadChecks.size();
   for (const std::string &Str : ExtraBadChecks) {
     if (Str.empty())
       continue;
     Size += Seperator.size();
     if (LLVM_LIKELY(Str.front() != '-'))
       ++Size;

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`cppcoreguidelines-rvalue-reference-param-not-moved
   <clang-tidy/checks/cppcoreguidelines/rvalue-reference-param-not-moved>` check.
 
   Warns when an rvalue reference function parameter is never moved within
   the function body.
 
 - New :doc:`llvmlibc-inline-function-decl
   <clang-tidy/checks/llvmlibc/inline-function-decl>` check.
 
   Checks that all implicit and explicit inline functions in header files are
   tagged with the ``LIBC_INLINE`` macro.
 
+- New :doc:`misc-include-cleaner
+  <clang-tidy/checks/misc/include-cleaner>` check.
+
+  Checks for unused and missing includes.
+
 - New :doc:`modernize-type-traits
   <clang-tidy/checks/modernize/type-traits>` check.
 
   Converts standard library type traits of the form ``traits<...>::type`` and
   ``traits<...>::value`` into ``traits_t<...>`` and ``traits_v<...>`` respectively.
 
 - New :doc:`performance-avoid-endl
   <clang-tidy/checks/performance/avoid-endl>` check.
 
   Finds uses of ``std::endl`` on streams and replaces them with ``'\n'``.
 
 - New :doc:`readability-avoid-unconditional-preprocessor-if
   <clang-tidy/checks/readability/avoid-unconditional-preprocessor-if>` check.
 
   Finds code blocks that are constantly enabled or disabled in preprocessor
   directives by analyzing ``#if`` conditions, such as ``#if 0`` and
   ``#if 1``, etc.
 
 - New :doc:`readability-operators-representation
   <clang-tidy/checks/readability/operators-representation>` check.
 
   Enforces consistent token representation for invoked binary, unary and
   overloaded operators in C++ code.
 
 New check aliases
 ^^^^^^^^^^^^^^^^^
 
 - New alias :doc:`cert-msc24-c
   <clang-tidy/checks/cert/msc24-c>` to :doc:`bugprone-unsafe-functions
   <clang-tidy/checks/bugprone/unsafe-functions>` was added.
 
 - New alias :doc:`cert-msc33-c
   <clang-tidy/checks/cert/msc33-c>` to :doc:`bugprone-unsafe-functions
   <clang-tidy/checks/bugprone/unsafe-functions>` was added.
 
 - New alias :doc:`cppcoreguidelines-use-default-member-init

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `llvm-twine-local <llvm/twine-local.html>`_, "Yes"
    `llvmlibc-callee-namespace <llvmlibc/callee-namespace.html>`_,
    `llvmlibc-implementation-in-namespace <llvmlibc/implementation-in-namespace.html>`_,
    `llvmlibc-inline-function-decl <llvmlibc/inline-function-decl.html>`_,
    `llvmlibc-restrict-system-libc-headers <llvmlibc/restrict-system-libc-headers.html>`_, "Yes"
    `misc-confusable-identifiers <misc/confusable-identifiers.html>`_,
    `misc-const-correctness <misc/const-correctness.html>`_, "Yes"
    `misc-definitions-in-headers <misc/definitions-in-headers.html>`_, "Yes"
+   `misc-include-cleaner <misc/include-cleaner.html>`_, "Yes"
    `misc-misleading-bidirectional <misc/misleading-bidirectional.html>`_,
    `misc-misleading-identifier <misc/misleading-identifier.html>`_,
    `misc-misplaced-const <misc/misplaced-const.html>`_,
    `misc-new-delete-overloads <misc/new-delete-overloads.html>`_,
    `misc-no-recursion <misc/no-recursion.html>`_,
    `misc-non-copyable-objects <misc/non-copyable-objects.html>`_,
    `misc-non-private-member-variables-in-classes <misc/non-private-member-variables-in-classes.html>`_,
    `misc-redundant-expression <misc/redundant-expression.html>`_, "Yes"
.. csv-table::
    `modernize-replace-disallow-copy-and-assign-macro <modernize/replace-disallow-copy-and-assign-macro.html>`_, "Yes"
    `modernize-replace-random-shuffle <modernize/replace-random-shuffle.html>`_, "Yes"
    `modernize-return-braced-init-list <modernize/return-braced-init-list.html>`_, "Yes"
    `modernize-shrink-to-fit <modernize/shrink-to-fit.html>`_, "Yes"
    `modernize-type-traits <modernize/type-traits.html>`_, "Yes"
    `modernize-unary-static-assert <modernize/unary-static-assert.html>`_, "Yes"
    `modernize-use-auto <modernize/use-auto.html>`_, "Yes"
    `modernize-use-bool-literals <modernize/use-bool-literals.html>`_, "Yes"
    `modernize-use-default-member-init <modernize/use-default-member-init.html>`_, "Yes"
    `modernize-use-emplace <modernize/use-emplace.html>`_, "Yes"
    `modernize-use-equals-default <modernize/use-equals-default.html>`_, "Yes"
    `modernize-use-equals-delete <modernize/use-equals-delete.html>`_, "Yes"
    `modernize-use-nodiscard <modernize/use-nodiscard.html>`_, "Yes"
    `modernize-use-noexcept <modernize/use-noexcept.html>`_, "Yes"
    `modernize-use-nullptr <modernize/use-nullptr.html>`_, "Yes"
    `modernize-use-override <modernize/use-override.html>`_, "Yes"
    `modernize-use-trailing-return-type <modernize/use-trailing-return-type.html>`_, "Yes"
.. csv-table:: Aliases..
    `clang-analyzer-unix.cstring.BadSizeArg <clang-analyzer/unix.cstring.BadSizeArg.html>`_, `Clang Static Analyzer unix.cstring.BadSizeArg <https://clang.llvm.org/docs/analyzer/checkers.html#unix-cstring-badsizearg>`_,
    `clang-analyzer-unix.cstring.NullArg <clang-analyzer/unix.cstring.NullArg.html>`_, `Clang Static Analyzer unix.cstring.NullArg <https://clang.llvm.org/docs/analyzer/checkers.html#unix-cstring-nullarg>`_,
    `cppcoreguidelines-avoid-c-arrays <cppcoreguidelines/avoid-c-arrays.html>`_, `modernize-avoid-c-arrays <modernize/avoid-c-arrays.html>`_,
    `cppcoreguidelines-avoid-magic-numbers <cppcoreguidelines/avoid-magic-numbers.html>`_, `readability-magic-numbers <readability/magic-numbers.html>`_,
    `cppcoreguidelines-c-copy-assignment-signature <cppcoreguidelines/c-copy-assignment-signature.html>`_, `misc-unconventional-assign-operator <misc/unconventional-assign-operator.html>`_,
    `cppcoreguidelines-explicit-virtual-functions <cppcoreguidelines/explicit-virtual-functions.html>`_, `modernize-use-override <modernize/use-override.html>`_, "Yes"
    `cppcoreguidelines-macro-to-enum <cppcoreguidelines/macro-to-enum.html>`_, `modernize-macro-to-enum <modernize/macro-to-enum.html>`_, "Yes"
    `cppcoreguidelines-non-private-member-variables-in-classes <cppcoreguidelines/non-private-member-variables-in-classes.html>`_, `misc-non-private-member-variables-in-classes <misc/non-private-member-variables-in-classes.html>`_,
    `cppcoreguidelines-use-default-member-init <cppcoreguidelines/use-default-member-init.html>`_, `modernize-use-default-member-init <modernize/use-default-member-init.html>`_,
    `fuchsia-header-anon-namespaces <fuchsia/header-anon-namespaces.html>`_, `google-build-namespaces <google/build-namespaces.html>`_,
    `google-readability-braces-around-statements <google/readability-braces-around-statements.html>`_, `readability-braces-around-statements <readability/braces-around-statements.html>`_, "Yes"
    `google-readability-function-size <google/readability-function-size.html>`_, `readability-function-size <readability/function-size.html>`_,
    `google-readability-namespace-comments <google/readability-namespace-comments.html>`_, `llvm-namespace-comment <llvm/namespace-comment.html>`_,
    `hicpp-avoid-c-arrays <hicpp/avoid-c-arrays.html>`_, `modernize-avoid-c-arrays <modernize/avoid-c-arrays.html>`_,
    `hicpp-braces-around-statements <hicpp/braces-around-statements.html>`_, `readability-braces-around-statements <readability/braces-around-statements.html>`_, "Yes"
    `hicpp-deprecated-headers <hicpp/deprecated-headers.html>`_, `modernize-deprecated-headers <modernize/deprecated-headers.html>`_, "Yes"
    `hicpp-explicit-conversions <hicpp/explicit-conversions.html>`_, `google-explicit-constructor <google/explicit-constructor.html>`_, "Yes"

clang-tools-extra/docs/clang-tidy/checks/misc/include-cleaner.rst

+.. title:: clang-tidy - misc-include-cleaner
+
+misc-include-cleaner
+====================
+
+Checks for unused and missing includes. Generates findings only for
+the main file of a translation unit.
+Findings correspond to https://clangd.llvm.org/design/include-cleaner.
+
+Example:
+
+.. code-block:: c++
+   // foo.h
+   class Foo{};
+   // bar.h
+   #include "baz.h"
+   class Bar{};
+   // baz.h
+   class Baz{};
+   // main.cc
+   #include "bar.h" // OK: uses class Bar from bar.h
+   #include "foo.h" // warning: unused include "foo.h"
+   Bar bar;
+   Baz baz; // warning: missing include "baz.h"
+
+Options
+-------
+
+.. option:: IgnoreHeaders
+
+   A semicolon-separated list of regexes to disable insertion/removal of header
+   files that match this regex as a suffix.  E.g., `foo/.*` disables
+   insertion/removal for all headers under the directory `foo`. By default, no 
+   headers will be ignored.

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/Basic/SourceLocation.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 <vector>

 /// step to determine the final public header rather than the header directly
 /// defines the symbol.
 class PragmaIncludes {
 public:
   /// Installs an analysing PPCallback and CommentHandler and populates results
   /// to the structure.
   void record(const CompilerInstance &CI);
 
+  /// Installs an analysing PPCallback and CommentHandler and populates results
+  /// to the structure.
+  void record(Preprocessor &P);
+
   /// Returns true if the given #include of the main-file should never be
   /// removed.
   bool shouldKeep(unsigned HashLineNumber) const {
     return ShouldKeep.contains(HashLineNumber);
   }
 
   /// Returns the public mapping include for the given physical header file.
   /// Returns "" if there is none.

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

 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/MacroInfo.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/Inclusions/HeaderAnalysis.h"
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
+#include <memory>
+#include <utility>
 
 namespace clang::include_cleaner {
 namespace {
 
 class PPRecorder : public PPCallbacks {
 public:
   PPRecorder(RecordedPP &Recorded, const Preprocessor &PP)
       : Recorded(Recorded), PP(PP), SM(PP.getSourceManager()) {}
private:
   const Preprocessor &PP;
   const SourceManager &SM;
 };
 
 } // namespace
 
 class PragmaIncludes::RecordPragma : public PPCallbacks, public CommentHandler {
 public:
   RecordPragma(const CompilerInstance &CI, PragmaIncludes *Out)
-      : SM(CI.getSourceManager()),
-        HeaderInfo(CI.getPreprocessor().getHeaderSearchInfo()), Out(Out),
+      : RecordPragma(CI.getPreprocessor(), Out) {}
+  RecordPragma(const Preprocessor &P, PragmaIncludes *Out)
+      : SM(P.getSourceManager()), HeaderInfo(P.getHeaderSearchInfo()), Out(Out),
         UniqueStrings(Arena) {}
 
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override {
     InMainFile = SM.isWrittenInMainFile(Loc);
 
     if (Reason == PPCallbacks::ExitFile) {
       // At file exit time HeaderSearchInfo is valid and can be used to
       // determine whether the file was a self-contained header or not.
       if (const FileEntry *FE = SM.getFileEntryForID(PrevFID)) {

 };
 
 void PragmaIncludes::record(const CompilerInstance &CI) {
   auto Record = std::make_unique<RecordPragma>(CI, this);
   CI.getPreprocessor().addCommentHandler(Record.get());
   CI.getPreprocessor().addPPCallbacks(std::move(Record));
 }
 
+void PragmaIncludes::record(Preprocessor &P) {
+  auto Record = std::make_unique<RecordPragma>(P, this);
+  P.addCommentHandler(Record.get());
+  P.addPPCallbacks(std::move(Record));
+}
+
 llvm::StringRef PragmaIncludes::getPublic(const FileEntry *F) const {
   auto It = IWYUPublic.find(F->getUniqueID());
   if (It == IWYUPublic.end())
     return "";
   return It->getSecond();
 }
 
 static llvm::SmallVector<const FileEntry *>
-toFileEntries(llvm::ArrayRef<StringRef> FileNames, FileManager& FM) {
-    llvm::SmallVector<const FileEntry *> Results;
+toFileEntries(llvm::ArrayRef<StringRef> FileNames, FileManager &FM) {
 
   for (auto FName : FileNames) {
     // FIMXE: log the failing cases?
     if (auto FE = expectedToOptional(FM.getFileRef(FName)))
       Results.push_back(*FE);
   }
   return Results;
 }

clang-tools-extra/test/clang-tidy/checkers/misc/Inputs/bar.h

+#pragma once
+#include "baz.h"
+#include "private.h"
+int bar();

clang-tools-extra/test/clang-tidy/checkers/misc/Inputs/baz.h

+#pragma once
+int baz();

clang-tools-extra/test/clang-tidy/checkers/misc/Inputs/foo.h

+#pragma once
+void foo();

clang-tools-extra/test/clang-tidy/checkers/misc/Inputs/private.h

+// IWYU pragma: private, include "public.h"
+int foobar();

clang-tools-extra/test/clang-tidy/checkers/misc/include-cleaner.cpp

+// RUN: %check_clang_tidy %s misc-include-cleaner %t -- -- -I%S/Inputs -isystem%S/system
+#include "bar.h"
+// CHECK-FIXES: {{^}}#include "baz.h"{{$}}
+#include "foo.h"
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: included header "foo.h" is not used directly [misc-include-cleaner]
+// CHECK-FIXES: {{^}}
+// CHECK-FIXES: {{^}}#include <string>{{$}}
+#include <vector.h>
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: included header <vector.h> is not used directly [misc-include-cleaner]
+// CHECK-FIXES: {{^}}
+int BarResult = bar();
+int BazResult = baz();
+// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: no header providing "baz.h" is directly included [misc-include-cleaner]
+std::string HelloString;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: no header providing <string> is directly included [misc-include-cleaner]
+int FooBarResult = foobar();
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: no header providing "public.h" is directly included [misc-include-cleaner]

clang-tools-extra/test/clang-tidy/checkers/misc/system/string.h

+#pragma once
+namespace std { class string {}; }

clang-tools-extra/test/clang-tidy/checkers/misc/system/vector.h

+#pragma once
+#include <string.h>
+
+namespace std { class vector {}; }

clang-tools-extra/unittests/clang-tidy/CMakeLists.txt

if (EXISTS ${LLVM_MAIN_SRC_DIR}/lib/Testing/Support
     add_subdirectory(${LLVM_MAIN_SRC_DIR}/lib/Testing/Support
       lib/Testing/Support)
   endif()
 endif()
 
 get_filename_component(CLANG_LINT_SOURCE_DIR
   ${CMAKE_CURRENT_SOURCE_DIR}/../../clang-tidy REALPATH)
 include_directories(${CLANG_LINT_SOURCE_DIR})
+include_directories(BEFORE "${CMAKE_CURRENT_SOURCE_DIR}/../../include-cleaner/include")
 
 add_extra_unittest(ClangTidyTests
   AddConstTest.cpp
   ClangTidyDiagnosticConsumerTest.cpp
   ClangTidyOptionsTest.cpp
   DeclRefExprUtilsTest.cpp
+  IncludeCleanerTest.cpp
   IncludeInserterTest.cpp
   GlobListTest.cpp
   GoogleModuleTest.cpp
   LLVMModuleTest.cpp
   ModernizeModuleTest.cpp
   NamespaceAliaserTest.cpp
   ObjCModuleTest.cpp
   OptionsProviderTest.cpp
clang_target_link_libraries(ClangTidyTests
   clangASTMatchers
   clangBasic
   clangFrontend
   clangLex
   clangSerialization
   clangTooling
   clangToolingCore
   clangTransformer
+  clangIncludeCleaner
   )
 target_link_libraries(ClangTidyTests
   PRIVATE
   clangTidy
   clangTidyAndroidModule
   clangTidyGoogleModule
+  clangTidyMiscModule
   clangTidyLLVMModule
   clangTidyModernizeModule
   clangTidyObjCModule
   clangTidyReadabilityModule
   clangTidyUtils
   LLVMTestingAnnotations
   LLVMTestingSupport
   )

clang-tools-extra/unittests/clang-tidy/IncludeCleanerTest.cpp

+//===--- IncludeCleanerTest.cpp - clang-tidy -----------------------------===//
+//
+// 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 "ClangTidyDiagnosticConsumer.h"
+#include "ClangTidyOptions.h"
+#include "ClangTidyTest.h"
+#include "misc/IncludeCleanerCheck.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Regex.h"
+#include "gtest/gtest.h"
+#include <initializer_list>
+
+#include <optional>
+#include <vector>
+
+using namespace clang::tidy::misc;
+
+namespace clang {
+namespace tidy {
+namespace test {
+namespace {
+
+std::string
+appendPathFileSystemIndependent(std::initializer_list<std::string> Segments) {
+  llvm::SmallString<32> Result;
+  for (const auto &Segment : Segments)
+    llvm::sys::path::append(Result, llvm::sys::path::Style::native, Segment);
+  return std::string(Result.str());
+}
+
+TEST(IncludeCleanerCheckTest, BasicUnusedIncludes) {
+  const char *PreCode = R"(
+#include "bar.h"
+#include <vector>
+#include "bar.h"
+)";
+  const char *PostCode = "\n";
+
+  std::vector<ClangTidyError> Errors;
+  EXPECT_EQ(PostCode, runCheckOnCode<IncludeCleanerCheck>(
+                          PreCode, &Errors, "file.cpp", std::nullopt,
+                          ClangTidyOptions(), {{"bar.h", ""}, {"vector", ""}}));
+}
+
+TEST(IncludeCleanerCheckTest, SuppressUnusedIncludes) {
+  const char *PreCode = R"(
+#include "bar.h"
+#include "foo/qux.h"
+#include "baz/qux/qux.h"
+#include <vector>
+)";
+
+  const char *PostCode = R"(
+#include "bar.h"
+#include "foo/qux.h"
+#include <vector>
+)";
+
+  std::vector<ClangTidyError> Errors;
+  ClangTidyOptions Opts;
+  Opts.CheckOptions["IgnoreHeaders"] = llvm::StringRef{llvm::formatv(
+      "bar.h;{0};{1};vector",
+      llvm::Regex::escape(appendPathFileSystemIndependent({"foo", "qux.h"})),
+      llvm::Regex::escape(appendPathFileSystemIndependent({"baz", "qux"})))};
+  EXPECT_EQ(
+      PostCode,
+      runCheckOnCode<IncludeCleanerCheck>(
+          PreCode, &Errors, "file.cpp", std::nullopt, Opts,
+          {{"bar.h", ""},
+           {"vector", ""},
+           {appendPathFileSystemIndependent({"foo", "qux.h"}), ""},
+           {appendPathFileSystemIndependent({"baz", "qux", "qux.h"}), ""}}));
+}
+
+TEST(IncludeCleanerCheckTest, BasicMissingIncludes) {
+  const char *PreCode = R"(
+#include "bar.h"
+
+int BarResult = bar();
+int BazResult = baz();
+)";
+  const char *PostCode = R"(
+#include "bar.h"
+#include "baz.h"
+
+int BarResult = bar();
+int BazResult = baz();
+)";
+
+  std::vector<ClangTidyError> Errors;
+  EXPECT_EQ(PostCode,
+            runCheckOnCode<IncludeCleanerCheck>(
+                PreCode, &Errors, "file.cpp", std::nullopt, ClangTidyOptions(),
+                {{"bar.h", R"(#pragma once
+                              #include "baz.h"
+                              int bar();
+                           )"},
+                 {"baz.h", R"(#pragma once
+                              int baz();
+                           )"}}));
+}
+
+TEST(IncludeCleanerCheckTest, SuppressMissingIncludes) {
+  const char *PreCode = R"(
+#include "bar.h"
+
+int BarResult = bar();
+int BazResult = baz();
+int QuxResult = qux();
+)";
+
+  ClangTidyOptions Opts;
+  Opts.CheckOptions["IgnoreHeaders"] = llvm::StringRef{
+      "baz.h;" +
+      llvm::Regex::escape(appendPathFileSystemIndependent({"foo", "qux.h"}))};
+  std::vector<ClangTidyError> Errors;
+  EXPECT_EQ(PreCode, runCheckOnCode<IncludeCleanerCheck>(
+                         PreCode, &Errors, "file.cpp", std::nullopt, Opts,
+                         {{"bar.h", R"(#pragma once
+                              #include "baz.h"
+                              #include "foo/qux.h"
+                              int bar();
+                           )"},
+                          {"baz.h", R"(#pragma once
+                              int baz();
+                           )"},
+                          {appendPathFileSystemIndependent({"foo", "qux.h"}),
+                           R"(#pragma once
+                              int qux();
+                           )"}}));
+}
+
+TEST(IncludeCleanerCheckTest, SystemMissingIncludes) {
+  const char *PreCode = R"(
+#include <vector>
+
+std::string HelloString;
+std::vector Vec;
+)";
+  const char *PostCode = R"(
+#include <string>
+#include <vector>
+
+std::string HelloString;
+std::vector Vec;
+)";
+
+  std::vector<ClangTidyError> Errors;
+  EXPECT_EQ(PostCode,
+            runCheckOnCode<IncludeCleanerCheck>(
+                PreCode, &Errors, "file.cpp", std::nullopt, ClangTidyOptions(),
+                {{"string", R"(#pragma once
+                              namespace std { class string {}; }
+                            )"},
+                 {"vector", R"(#pragma once
+                              #include <string>
+                              namespace std { class vector {}; }
+                            )"}}));
+}
+
+TEST(IncludeCleanerCheckTest, PragmaMissingIncludes) {
+  const char *PreCode = R"(
+#include "bar.h"
+
+int BarResult = bar();
+int FooBarResult = foobar();
+)";
+  const char *PostCode = R"(
+#include "bar.h"
+#include "public.h"
+
+int BarResult = bar();
+int FooBarResult = foobar();
+)";
+
+  std::vector<ClangTidyError> Errors;
+  EXPECT_EQ(PostCode,
+            runCheckOnCode<IncludeCleanerCheck>(
+                PreCode, &Errors, "file.cpp", std::nullopt, ClangTidyOptions(),
+                {{"bar.h", R"(#pragma once
+                              #include "private.h"
+                              int bar();
+                           )"},
+                 {"private.h", R"(#pragma once
+                                // IWYU pragma: private, include "public.h"
+                                int foobar();
+                               )"}}));
+}
+
+TEST(IncludeCleanerCheckTest, DeclFromMacroExpansion) {
+  const char *PreCode = R"(
+#include "foo.h"
+
+DECLARE(myfunc) {
+   int a;
+}
+)";
+
+  std::vector<ClangTidyError> Errors;
+  EXPECT_EQ(PreCode,
+            runCheckOnCode<IncludeCleanerCheck>(
+                PreCode, &Errors, "file.cpp", std::nullopt, ClangTidyOptions(),
+                {{"foo.h",
+                  R"(#pragma once
+                     #define DECLARE(X) void X()
+                  )"}}));
+
+  PreCode = R"(
+#include "foo.h"
+
+DECLARE {
+   int a;
+}
+)";
+
+  EXPECT_EQ(PreCode,
+            runCheckOnCode<IncludeCleanerCheck>(
+                PreCode, &Errors, "file.cpp", std::nullopt, ClangTidyOptions(),
+                {{"foo.h",
+                  R"(#pragma once
+                     #define DECLARE void myfunc()
+                  )"}}));
+}
+
+} // namespace
+} // namespace test
+} // namespace tidy
+} // namespace clang