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

[Eugene.Zelenko]

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

5

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

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

49 ↗

(On Diff #520307)

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.

57 ↗

(On Diff #520307)

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?

93 ↗

(On Diff #520307)

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

104 ↗

(On Diff #520307)

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)

106–109 ↗

(On Diff #520307)

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

113 ↗

(On Diff #520307)

again you can use ClangTidyCheck::getCurrentMainFile()

114 ↗

(On Diff #520307)

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

116 ↗

(On Diff #520307)

no need for braces

123–124 ↗

(On Diff #520307)

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

125 ↗

(On Diff #520307)

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

139 ↗

(On Diff #520307)

you can use the substitution alternative mentioned above here as well

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

25 ↗

(On Diff #520307)

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

clang-tools-extra/docs/ReleaseNotes.rst

174

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

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

293

could you revert this change?

481

could you revert this change?

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

6 ↗

(On Diff #520307)

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

153

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

157

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

351

same here, no need to pass SM separately

[VitaNuo]

Address review comments.

[kadircet]

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

61 ↗

(On Diff #524336)

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.

66 ↗

(On Diff #524336)

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

66 ↗

(On Diff #524336)

s/Suppress/IgnoreHeader

to be consistent with option in clangd

81 ↗

(On Diff #524336)

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?

101 ↗

(On Diff #524336)

we should also respect IgnoreHeaders here

126 ↗

(On Diff #524336)

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.

131 ↗

(On Diff #524336)

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

144 ↗

(On Diff #524336)

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

43 ↗

(On Diff #524336)

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

8 ↗

(On Diff #524336)

can you also mention the check options for ignoring analysis?

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

18 ↗

(On Diff #524336)

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

37 ↗

(On Diff #524336)

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

42 ↗

(On Diff #526064)

let's put this struct into anon namespace

48 ↗

(On Diff #526064)

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++.

67 ↗

(On Diff #526064)

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.

72 ↗

(On Diff #526064)

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

83 ↗

(On Diff #526064)

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

107 ↗

(On Diff #526064)

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

48 ↗

(On Diff #526064)

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

15 ↗

(On Diff #526064)

[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

48 ↗

(On Diff #526064)

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

67 ↗

(On Diff #526064)

Thanks, good ideas!

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

15 ↗

(On Diff #526064)

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

86 ↗

(On Diff #526558)

auto -> const Decl*

170–175 ↗

(On Diff #526558)

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

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

28–29 ↗

(On Diff #526558)

this description does not match first sentence in check documentation.

42 ↗

(On Diff #526558)

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

44 ↗

(On Diff #526558)

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

47 ↗

(On Diff #526558)

llvm::Regex got constructor, use emplace_back

55 ↗

(On Diff #526558)

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

174

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.

174

This description does not match first sentence in check documentation.

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

6 ↗

(On Diff #526558)

avoid "The check"

9 ↗

(On Diff #526558)

Try adding some very simple "example"

17 ↗

(On Diff #526558)

add some info about default value, is there any ?

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

9 ↗

(On Diff #526558)

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

[PiotrZSL]

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

9 ↗

(On Diff #526558)

nwm, somehow I missed one file.

19 ↗

(On Diff #526558)

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

45 ↗

(On Diff #526558)

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.

88 ↗

(On Diff #526558)

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.

89 ↗

(On Diff #526558)

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.

130 ↗

(On Diff #526558)

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

149 ↗

(On Diff #526558)

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

36 ↗

(On Diff #526558)

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

clang-tools-extra/clangd/TidyProvider.cpp

220 ↗

(On Diff #526558)

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

13 ↗

(On Diff #526558)

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

[hokein]

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

1 ↗

(On Diff #526558)

nit: missing the license file comment.

[hokein]

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

170–175 ↗

(On Diff #526558)

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

86 ↗

(On Diff #526558)

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.

88 ↗

(On Diff #526558)

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.

81 ↗

(On Diff #524336)

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?

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

42 ↗

(On Diff #526558)

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

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

19 ↗

(On Diff #526558)

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

171

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

174

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

88 ↗

(On Diff #526558)

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.

116 ↗

(On Diff #527001)

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?

194 ↗

(On Diff #527001)

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

21 ↗

(On Diff #527001)

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

4 ↗

(On Diff #527001)

nit: remove extra trailing ==

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

1 ↗

(On Diff #527001)

nit: IncludeCleanerTest.cpp

[VitaNuo]

Update release notes.

[VitaNuo]

Address review comments.

[VitaNuo]

Thanks for the comments!

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

88 ↗

(On Diff #526558)

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

189–193 ↗

(On Diff #527329)

nit: we can simplify it like

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

88 ↗

(On Diff #526558)

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.

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

27 ↗

(On Diff #527329)

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

70 ↗

(On Diff #527329)

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/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   )
 
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/clang-tidy-config.h.cmake
   ${CMAKE_CURRENT_BINARY_DIR}/clang-tidy-config.h)
 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR})
+include_directories(BEFORE "${CMAKE_CURRENT_SOURCE_DIR}/../include-cleaner/include")
 
 add_clang_library(clangTidy
   ClangTidy.cpp
   ClangTidyCheck.cpp
   ClangTidyModule.cpp
   ClangTidyDiagnosticConsumer.cpp
   ClangTidyOptions.cpp
   ClangTidyProfiling.cpp
clang_target_link_libraries(clangTidy
   clangFormat
   clangFrontend
   clangLex
   clangRewrite
   clangSema
   clangSerialization
   clangTooling
   clangToolingCore
+  clangIncludeCleaner
   )
 
 if(CLANG_TIDY_ENABLE_STATIC_ANALYZER)
   clang_target_link_libraries(clangTidy
     PRIVATE
     clangStaticAnalyzerCore
     clangStaticAnalyzerFrontend
   )

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

add_clang_library(clangTidyGoogleModule
   AvoidUnderscoreInGoogletestNameCheck.cpp
   DefaultArgumentsCheck.cpp
   ExplicitConstructorCheck.cpp
   ExplicitMakePairCheck.cpp
   FunctionNamingCheck.cpp
   GlobalNamesInHeadersCheck.cpp
   GlobalVariableDeclarationCheck.cpp
   GoogleTidyModule.cpp
+  IncludeCleanerCheck.cpp
   IntegerTypesCheck.cpp
   OverloadedUnaryAndCheck.cpp
   TodoCommentCheck.cpp
   UnnamedNamespaceInHeaderCheck.cpp
   UpgradeGoogletestCaseCheck.cpp
   UsingNamespaceDirectiveCheck.cpp
 
   LINK_LIBS

clang-tools-extra/clang-tidy/google/GoogleTidyModule.cpp

 #include "AvoidThrowingObjCExceptionCheck.h"
 #include "AvoidUnderscoreInGoogletestNameCheck.h"
 #include "DefaultArgumentsCheck.h"
 #include "ExplicitConstructorCheck.h"
 #include "ExplicitMakePairCheck.h"
 #include "FunctionNamingCheck.h"
 #include "GlobalNamesInHeadersCheck.h"
 #include "GlobalVariableDeclarationCheck.h"
+#include "IncludeCleanerCheck.h"
 #include "IntegerTypesCheck.h"
 #include "OverloadedUnaryAndCheck.h"
 #include "TodoCommentCheck.h"
 #include "UnnamedNamespaceInHeaderCheck.h"
 #include "UpgradeGoogletestCaseCheck.h"
 #include "UsingNamespaceDirectiveCheck.h"
 
 using namespace clang::ast_matchers;
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<build::UsingNamespaceDirectiveCheck>(
         "google-build-using-namespace");
     CheckFactories.registerCheck<DefaultArgumentsCheck>(
         "google-default-arguments");
     CheckFactories.registerCheck<ExplicitConstructorCheck>(
         "google-explicit-constructor");
     CheckFactories.registerCheck<readability::GlobalNamesInHeadersCheck>(
         "google-global-names-in-headers");
+    CheckFactories.registerCheck<IncludeCleanerCheck>("google-include-cleaner");
     CheckFactories.registerCheck<objc::AvoidNSObjectNewCheck>(
         "google-objc-avoid-nsobject-new");
     CheckFactories.registerCheck<objc::AvoidThrowingObjCExceptionCheck>(
         "google-objc-avoid-throwing-exception");
     CheckFactories.registerCheck<objc::FunctionNamingCheck>(
         "google-objc-function-naming");
     CheckFactories.registerCheck<objc::GlobalVariableDeclarationCheck>(
         "google-objc-global-variable-declaration");

clang-tools-extra/clang-tidy/google/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_GOOGLE_INCLUDECLEANERCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_INCLUDECLEANERCHECK_H
+
+#include "../ClangTidyCheck.h"
+#include "../ClangTidyDiagnosticConsumer.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 "clang/Tooling/Syntax/Tokens.h"
+#include <string>
+#include <vector>
+
+namespace clang::tidy::google {
+
+struct MissingIncludeInfo {
+  SourceLocation SymRefLocation;
+  std::string MissingHeaderSpelling;
+};
+
+/// FIXME: Write a short description.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/google/include-cleaner.html
+class IncludeCleanerCheck : public ClangTidyCheck {
+public:
+  IncludeCleanerCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, 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 onEndOfTranslationUnit() override;
+
+private:
+  include_cleaner::RecordedPP RecordedPreprocessor;
+  include_cleaner::PragmaIncludes RecordedPI;
+  HeaderSearch *HS;
+  Decl *TUDecl;
+  const SourceManager *SM;
+};
+
+} // namespace clang::tidy::google
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_INCLUDECLEANERCHECK_H

clang-tools-extra/clang-tidy/google/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 "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/DeclBase.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/FileEntry.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/ArrayRef.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/StringRef.h"
+#include <optional>
+#include <string>
+#include <vector>
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::google {
+
+void IncludeCleanerCheck::registerMatchers(MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus)
+    return;
+  Finder->addMatcher(translationUnitDecl().bind("top"), this);
+}
+
+void IncludeCleanerCheck::registerPPCallbacks(const SourceManager &SM,
+                                              Preprocessor *PP,
+                                              Preprocessor *ModuleExpanderPP) {
+  // llvm::errs() << "Registering PP callbacks!!\n";
+  PP->addPPCallbacks(RecordedPreprocessor.record(*PP));
+  HS = &PP->getHeaderSearchInfo();
+  RecordedPI.record(SM, *PP);
+}
+
+void IncludeCleanerCheck::check(const MatchFinder::MatchResult &Result) {
+  // llvm::errs() << "Running the check!!\n";
+  TUDecl = const_cast<Decl *>(Result.Nodes.getNodeAs<Decl>("top"));
+  SM = Result.SourceManager;
+
+  // llvm::errs() << "Finished!!\n";
+}
+
+// TODO(bakalova) Write unit tests
+// TODO(bakalova) Refactor/cleanup
+// TODO(bakalova) Write docs
+void IncludeCleanerCheck::onEndOfTranslationUnit() {
+  const FileEntry *MainFile = SM->getFileEntryForID(SM->getMainFileID());
+  llvm::DenseSet<const include_cleaner::Include *> Used;
+  std::vector<MissingIncludeInfo> Missing;
+  // llvm::errs() << "Let's run the analysis!!\n";
+  walkUsed(TUDecl, RecordedPreprocessor.MacroReferences, &RecordedPI, *SM,
+           [&](const include_cleaner::SymbolReference &Ref,
+               llvm::ArrayRef<include_cleaner::Header> Providers) {
+             //  std::string SymName;
+             //  switch (Ref.Target.kind()) {
+             //  case include_cleaner::Symbol::Declaration:
+             //    SymName =
+             //    llvm::dyn_cast<NamedDecl>(&Ref.Target.declaration())
+             //               ->getQualifiedNameAsString();
+             //    llvm::errs() << SymName << "\n";
+             //    break;
+             //  }
+             bool Satisfied = false;
+             for (const include_cleaner::Header &H : Providers) {
+               // llvm::errs() << "Checking provider: " <<
+               // include_cleaner::spellHeader(H,
+               //                                               *HS, MainFile)
+               //                                               << "\n";
+               if (H.kind() == include_cleaner::Header::Physical &&
+                   H.physical() == MainFile)
+                 Satisfied = true;
+               // llvm::errs() << SymName << " satisfied because provided by
+               // main file\n";
+               for (const include_cleaner::Include *I :
+                    RecordedPreprocessor.Includes.match(H)) {
+                 Used.insert(I);
+                 Satisfied = true;
+                 // llvm::errs() << SymName << " satisfied because provider
+                 // matched\n";
+               }
+             }
+             if (!Satisfied && !Providers.empty() &&
+                 Ref.RT == include_cleaner::RefType::Explicit)
+               //  llvm::errs() << "missing include in walkUsed: "
+               //               <<
+               //               include_cleaner::spellHeader(Providers.front(),
+               //                                               *HS, MainFile)
+               //               << "\n";
+               Missing.push_back(
+                   {Ref.RefLocation, include_cleaner::spellHeader(
+                                         Providers.front(), *HS, MainFile)});
+           });
+
+  std::vector<const include_cleaner::Include *> Unused;
+  for (const include_cleaner::Include &I :
+       RecordedPreprocessor.Includes.all()) {
+    // llvm::errs() << "recorded include: " << I.quote() << "\n";
+    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 (MainFile->tryGetRealPathName().endswith(PHeader))
+        continue;
+    }
+
+    Unused.push_back(&I);
+  }
+
+  for (const auto *Inc : Unused) {
+    // llvm::errs() << "unused include in analysis: " << Inc->quote() << "\n";
+    std::string Description("Unused include ");
+    Description += Inc->quote();
+    diag(Inc->HashLocation, Description)
+        << FixItHint::CreateRemoval(Inc->HashLocation);
+  }
+
+  // TODO(bakalova) Move to separate function
+  auto FileStyle = format::getStyle(
+      format::DefaultFormatStyle, MainFile->tryGetRealPathName(),
+      format::DefaultFallbackStyle, SM->getBufferData(SM->getMainFileID()),
+      &SM->getFileManager().getVirtualFileSystem());
+  if (!FileStyle) {
+    FileStyle = format::getLLVMStyle();
+  }
+  for (const auto &Inc : Missing) {
+    // llvm::errs() << "missing include in analysis: " <<
+    // Inc.MissingHeaderSpelling
+    //              << "\n";
+    std::string Description("Missing include ");
+    Description += Inc.MissingHeaderSpelling;
+
+    // TODO(bakalova) Move to separate function
+    tooling::HeaderIncludes HeaderIncludes(
+        MainFile->tryGetRealPathName(), SM->getBufferData(SM->getMainFileID()),
+        FileStyle->IncludeStyle);
+    bool Angled = llvm::StringRef{Inc.MissingHeaderSpelling}.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.
+    std::optional<tooling::Replacement> Replacement = HeaderIncludes.insert(
+        llvm::StringRef{Inc.MissingHeaderSpelling}.trim("\"<>"), Angled,
+        tooling::IncludeDirective::Include);
+    if (!Replacement.has_value())
+      continue;
+    diag(Inc.SymRefLocation, Description) << FixItHint::CreateInsertion(
+        SM->getComposedLoc(SM->getMainFileID(), Replacement->getOffset()),
+        "#include " + Inc.MissingHeaderSpelling + "\n");
+  }
+}
+
+} // namespace clang::tidy::google

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`cppcoreguidelines-misleading-capture-default-by-value
   Warns when lambda specify a by-value capture default and capture ``this``.
 
 - 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:`google-include-cleaner
+  <clang-tidy/checks/google/include-cleaner>` check.
+
+  FIXME: add release notes.
+
 - 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:`modernize-type-traits
   <clang-tidy/checks/modernize/type-traits>` check.
- New :doc:`readability-avoid-unconditional-preprocessor-if
   ``#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/google/include-cleaner.rst

+.. title:: clang-tidy - google-include-cleaner
+
+google-include-cleaner
+======================
+
+FIXME: Describe what patterns does the check detect and why. Give examples.

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

.. csv-table::
    `fuchsia-trailing-return <fuchsia/trailing-return.html>`_,
    `fuchsia-virtual-inheritance <fuchsia/virtual-inheritance.html>`_,
    `google-build-explicit-make-pair <google/build-explicit-make-pair.html>`_,
    `google-build-namespaces <google/build-namespaces.html>`_,
    `google-build-using-namespace <google/build-using-namespace.html>`_,
    `google-default-arguments <google/default-arguments.html>`_,
    `google-explicit-constructor <google/explicit-constructor.html>`_, "Yes"
    `google-global-names-in-headers <google/global-names-in-headers.html>`_,
+   `google-include-cleaner <google/include-cleaner.html>`_, "Yes"
    `google-objc-avoid-nsobject-new <google/objc-avoid-nsobject-new.html>`_,
    `google-objc-avoid-throwing-exception <google/objc-avoid-throwing-exception.html>`_,
    `google-objc-function-naming <google/objc-function-naming.html>`_,
    `google-objc-global-variable-declaration <google/objc-global-variable-declaration.html>`_,
    `google-readability-avoid-underscore-in-googletest-name <google/readability-avoid-underscore-in-googletest-name.html>`_,
    `google-readability-casting <google/readability-casting.html>`_,
    `google-readability-todo <google/readability-todo.html>`_,
    `google-runtime-int <google/runtime-int.html>`_,
.. 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>`_,
+   `cppcoreguidelines-use-default-member-init <cppcoreguidelines/use-default-member-init.html>`_, `modernize-use-default-member-init <modernize/use-default-member-init.html>`_, "Yes"
    `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/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(const SourceManager &SM, 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 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),
         UniqueStrings(Arena) {}
+  RecordPragma(const SourceManager &SM, const Preprocessor &P, PragmaIncludes *Out)
+      : SM(SM),
+        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

 };
 
 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(const SourceManager &SM, Preprocessor &P) {
+  auto Record = std::make_unique<RecordPragma>(SM, 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 *>

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

+#pragma once
+#include "baz.h"
+#include "private.h"
+int bar();
 No newline at end of file

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

+#pragma once
+int baz();
 No newline at end of file

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

+#pragma once
+void foo();
 No newline at end of file

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

+ // IWYU pragma: private, include "public.h"
+int foobar();
 No newline at end of file

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

+// RUN: %check_clang_tidy %s google-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: Unused include "foo.h" [google-include-cleaner]
+// CHECK-FIXES: {{^}}
+// CHECK-FIXES: {{^}}#include <string>{{$}}
+#include <vector.h>
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: Unused include <vector.h> [google-include-cleaner]
+// CHECK-FIXES: {{^}}
+int BarResult = bar();
+int BazResult = baz();
+// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: Missing include "baz.h" [google-include-cleaner]
+std::string HelloString;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: Missing include <string> [google-include-cleaner]
+int FooBarResult = foobar();
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: Missing include "public.h" [google-include-cleaner]
 No newline at end of file

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

+#pragma once
+namespace std { class string {}; }
 No newline at end of file

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

+#pragma once
+#include <string.h>
+
+namespace std { class vector {}; }
 No newline at end of file