16#include "clang-include-cleaner/Analysis.h"
17#include "clang-include-cleaner/IncludeSpeller.h"
18#include "clang-include-cleaner/Record.h"
19#include "clang-include-cleaner/Types.h"
23#include "clang/AST/ASTContext.h"
24#include "clang/Basic/Diagnostic.h"
25#include "clang/Basic/LLVM.h"
26#include "clang/Basic/SourceLocation.h"
27#include "clang/Basic/SourceManager.h"
28#include "clang/Format/Format.h"
29#include "clang/Lex/DirectoryLookup.h"
30#include "clang/Lex/HeaderSearch.h"
31#include "clang/Lex/Preprocessor.h"
32#include "clang/Tooling/Core/Replacement.h"
33#include "clang/Tooling/Inclusions/HeaderIncludes.h"
34#include "clang/Tooling/Inclusions/StandardLibrary.h"
35#include "clang/Tooling/Syntax/Tokens.h"
36#include "llvm/ADT/ArrayRef.h"
37#include "llvm/ADT/DenseSet.h"
38#include "llvm/ADT/GenericUniformityImpl.h"
39#include "llvm/ADT/STLExtras.h"
40#include "llvm/ADT/SmallString.h"
41#include "llvm/ADT/SmallVector.h"
42#include "llvm/ADT/StringRef.h"
43#include "llvm/Support/Error.h"
44#include "llvm/Support/ErrorHandling.h"
45#include "llvm/Support/FormatVariadic.h"
46#include "llvm/Support/Path.h"
47#include "llvm/Support/Regex.h"
60bool isIgnored(llvm::StringRef HeaderPath,
HeaderFilter IgnoreHeaders) {
62 llvm::SmallString<64> NormalizedPath(HeaderPath);
63 llvm::sys::path::native(NormalizedPath, llvm::sys::path::Style::posix);
64 for (
auto &Filter : IgnoreHeaders) {
65 if (Filter(NormalizedPath))
71bool mayConsiderUnused(
const Inclusion &Inc, ParsedAST &
AST,
72 const include_cleaner::PragmaIncludes *PI) {
75 auto FE =
AST.getSourceManager().getFileManager().getFileRef(
76 AST.getIncludeStructure().getRealPath(HID));
78 if (FE->getDir() ==
AST.getPreprocessor()
79 .getHeaderSearchInfo()
83 if (PI && PI->shouldKeep(*FE))
88 if (Inc.Written.front() ==
'<')
89 return tooling::stdlib::Header::named(Inc.Written).has_value();
93 if (
auto PHeader = PI->getPublic(*FE); !PHeader.empty()) {
94 PHeader = PHeader.trim(
"<>\"");
98 if (
AST.tuPath().endswith(PHeader))
104 if (!
AST.getPreprocessor().getHeaderSearchInfo().isFileMultipleIncludeGuarded(
106 dlog(
"{0} doesn't have header guard and will not be considered unused",
113std::vector<Diag> generateMissingIncludeDiagnostics(
114 ParsedAST &
AST, llvm::ArrayRef<MissingIncludeDiagInfo> MissingIncludes,
116 std::vector<Diag> Result;
117 const SourceManager &SM =
AST.getSourceManager();
118 const FileEntry *
MainFile = SM.getFileEntryForID(SM.getMainFileID());
120 auto FileStyle = format::getStyle(
121 format::DefaultFormatStyle,
AST.tuPath(), format::DefaultFallbackStyle,
122 Code, &SM.getFileManager().getVirtualFileSystem());
124 elog(
"Couldn't infer style", FileStyle.takeError());
125 FileStyle = format::getLLVMStyle();
128 tooling::HeaderIncludes HeaderIncludes(
AST.tuPath(),
Code,
129 FileStyle->IncludeStyle);
130 for (
const auto &SymbolWithMissingInclude : MissingIncludes) {
131 llvm::StringRef ResolvedPath =
132 SymbolWithMissingInclude.Providers.front().resolvedPath();
133 if (isIgnored(ResolvedPath, IgnoreHeaders)) {
134 dlog(
"IncludeCleaner: not diagnosing missing include {0}, filtered by "
140 std::string Spelling = include_cleaner::spellHeader(
141 {SymbolWithMissingInclude.Providers.front(),
142 AST.getPreprocessor().getHeaderSearchInfo(),
MainFile});
144 llvm::StringRef HeaderRef{Spelling};
145 bool Angled = HeaderRef.starts_with(
"<");
150 std::optional<tooling::Replacement> Replacement = HeaderIncludes.insert(
151 HeaderRef.trim(
"\"<>"), Angled, tooling::IncludeDirective::Include);
152 if (!Replacement.has_value())
155 Diag &D = Result.emplace_back();
157 llvm::formatv(
"No header providing \"{0}\" is directly included",
158 SymbolWithMissingInclude.Symbol.name());
159 D.Name =
"missing-includes";
161 D.File =
AST.tuPath();
162 D.InsideMainFile =
true;
179 D.Severity = DiagnosticsEngine::Note;
180 D.Range = clangd::Range{
182 SymbolWithMissingInclude.SymRefRange.beginOffset()),
184 SymbolWithMissingInclude.SymRefRange.endOffset())};
185 auto &F = D.Fixes.emplace_back();
186 F.Message =
"#include " + Spelling;
188 F.Edits.emplace_back(std::move(Edit));
193std::vector<Diag> generateUnusedIncludeDiagnostics(
196 std::vector<Diag> Result;
197 for (
const auto *Inc : UnusedIncludes) {
198 if (isIgnored(Inc->Resolved, IgnoreHeaders))
200 Diag &D = Result.emplace_back();
202 llvm::formatv(
"included header {0} is not used directly",
203 llvm::sys::path::filename(
204 Inc->Written.substr(1, Inc->Written.size() - 2),
205 llvm::sys::path::Style::posix));
206 D.Name =
"unused-includes";
209 D.InsideMainFile =
true;
210 D.Severity = DiagnosticsEngine::Warning;
218 auto &F = D.Fixes.emplace_back();
219 F.Message =
"remove #include directive";
220 F.Edits.emplace_back();
221 F.Edits.back().range.start.line = Inc->HashLine;
222 F.Edits.back().range.end.line = Inc->HashLine + 1;
228removeAllUnusedIncludes(llvm::ArrayRef<Diag> UnusedIncludes) {
229 if (UnusedIncludes.empty())
233 RemoveAll.Message =
"remove all unused includes";
234 for (
const auto &Diag : UnusedIncludes) {
235 assert(Diag.Fixes.size() == 1 &&
"Expected exactly one fix.");
236 RemoveAll.Edits.insert(RemoveAll.Edits.end(),
237 Diag.Fixes.front().Edits.begin(),
238 Diag.Fixes.front().Edits.end());
242 ChangeAnnotation Annotation = {
"",
246 "RemoveAllUnusedIncludes";
247 for (
unsigned I = 0; I < RemoveAll.Edits.size(); ++I) {
249 RemoveAll.Edits[I].annotationId =
ID;
250 RemoveAll.Annotations.push_back({
ID, Annotation});
256addAllMissingIncludes(llvm::ArrayRef<Diag> MissingIncludeDiags) {
257 if (MissingIncludeDiags.empty())
261 AddAllMissing.Message =
"add all missing includes";
264 std::map<std::string, TextEdit> Edits;
265 for (
const auto &Diag : MissingIncludeDiags) {
266 assert(Diag.Fixes.size() == 1 &&
"Expected exactly one fix.");
267 for (
const auto &Edit : Diag.Fixes.front().Edits) {
268 Edits.try_emplace(Edit.newText, Edit);
272 ChangeAnnotation Annotation = {
"",
276 "AddAllMissingIncludes";
278 for (
auto &It : Edits) {
280 AddAllMissing.Edits.push_back(std::move(It.second));
281 AddAllMissing.Edits.back().annotationId =
ID;
283 AddAllMissing.Annotations.push_back({
ID, Annotation});
285 return AddAllMissing;
287Fix fixAll(
const Fix &RemoveAllUnused,
const Fix &AddAllMissing) {
289 FixAll.Message =
"fix all includes";
291 for (
const auto &F : RemoveAllUnused.Edits)
292 FixAll.Edits.push_back(F);
293 for (
const auto &F : AddAllMissing.Edits)
294 FixAll.Edits.push_back(F);
296 for (
const auto &A : RemoveAllUnused.Annotations)
297 FixAll.Annotations.push_back(A);
298 for (
const auto &A : AddAllMissing.Annotations)
299 FixAll.Annotations.push_back(A);
303std::vector<const Inclusion *>
304getUnused(ParsedAST &
AST,
305 const llvm::DenseSet<IncludeStructure::HeaderID> &ReferencedFiles) {
306 trace::Span Tracer(
"IncludeCleaner::getUnused");
307 std::vector<const Inclusion *>
Unused;
308 for (
const Inclusion &MFI :
AST.getIncludeStructure().MainFileIncludes) {
312 if (ReferencedFiles.contains(IncludeID))
314 if (!mayConsiderUnused(MFI,
AST,
AST.getPragmaIncludes().get())) {
315 dlog(
"{0} was not used, but is not eligible to be diagnosed as unused",
326std::vector<include_cleaner::SymbolReference>
328 const auto &SM =
AST.getSourceManager();
329 auto &PP =
AST.getPreprocessor();
330 std::vector<include_cleaner::SymbolReference> Macros;
331 for (
const auto &[_, Refs] :
AST.getMacros().MacroRefs) {
332 for (
const auto &
Ref : Refs) {
333 auto Loc = SM.getComposedLoc(SM.getMainFileID(),
Ref.StartOffset);
334 const auto *Tok =
AST.getTokens().spelledTokenAt(
Loc);
340 auto DefLoc =
Macro->NameLoc;
341 if (!DefLoc.isValid())
344 {include_cleaner::Macro{PP.getIdentifierInfo(Tok->text(SM)),
347 Ref.InConditionalDirective ? include_cleaner::RefType::Ambiguous
348 : include_cleaner::RefType::Explicit});
356 auto &SM =
AST.getSourceManager();
358 include_cleaner::Includes ConvertedIncludes;
361 for (
const auto &Dir :
AST.getIncludeStructure().SearchPathsCanonical)
362 ConvertedIncludes.addSearchDirectory(Dir);
364 for (
const Inclusion &Inc :
AST.getIncludeStructure().MainFileIncludes) {
365 include_cleaner::Include TransformedInc;
366 llvm::StringRef WrittenRef = llvm::StringRef(Inc.Written);
367 TransformedInc.Spelled = WrittenRef.trim(
"\"<>");
368 TransformedInc.HashLocation =
369 SM.getComposedLoc(SM.getMainFileID(), Inc.HashOffset);
370 TransformedInc.Line = Inc.HashLine + 1;
371 TransformedInc.Angled = WrittenRef.starts_with(
"<");
374 auto FE = SM.getFileManager().getFileRef(Inc.Resolved);
376 elog(
"IncludeCleaner: Failed to get an entry for resolved path {0}: {1}",
377 Inc.Resolved, FE.takeError());
380 TransformedInc.Resolved = *FE;
381 ConvertedIncludes.add(std::move(TransformedInc));
383 return ConvertedIncludes;
388 if (
AST.getLangOpts().ObjC)
390 const auto &SM =
AST.getSourceManager();
392 const FileEntry *
MainFile = SM.getFileEntryForID(SM.getMainFileID());
395 std::vector<include_cleaner::SymbolReference> Macros =
397 std::vector<MissingIncludeDiagInfo> MissingIncludes;
398 llvm::DenseSet<IncludeStructure::HeaderID> Used;
400 const DirectoryEntry *ResourceDir =
AST.getPreprocessor()
401 .getHeaderSearchInfo()
404 include_cleaner::walkUsed(
405 AST.getLocalTopLevelDecls(), Macros,
406 AST.getPragmaIncludes().get(),
AST.getPreprocessor(),
407 [&](
const include_cleaner::SymbolReference &
Ref,
408 llvm::ArrayRef<include_cleaner::Header> Providers) {
409 bool Satisfied = false;
410 for (const auto &H : Providers) {
411 if (H.kind() == include_cleaner::Header::Physical &&
412 (H.physical() == MainFile || H.physical() == PreamblePatch ||
413 H.physical().getDir() == ResourceDir)) {
417 for (auto *Inc : ConvertedIncludes.match(H)) {
420 AST.getIncludeStructure().getID(&Inc->Resolved->getFileEntry());
421 assert(HeaderID.has_value() &&
422 "ConvertedIncludes only contains resolved includes.");
423 Used.insert(*HeaderID);
427 if (Satisfied || Providers.empty() ||
428 Ref.RT != include_cleaner::RefType::Explicit)
438 auto Loc = SM.getFileLoc(
Ref.RefLocation);
441 while (SM.getFileID(
Loc) != SM.getMainFileID())
442 Loc = SM.getIncludeLoc(SM.getFileID(
Loc));
443 auto TouchingTokens =
444 syntax::spelledTokensTouching(
Loc,
AST.getTokens());
445 assert(!TouchingTokens.empty());
450 Ref.Target, TouchingTokens.back().range(SM), Providers};
451 MissingIncludes.push_back(std::move(DiagInfo));
456 llvm::stable_sort(MissingIncludes, [](
const MissingIncludeDiagInfo &LHS,
457 const MissingIncludeDiagInfo &RHS) {
459 if (LHS.SymRefRange != RHS.SymRefRange) {
462 return LHS.SymRefRange.beginOffset() < RHS.SymRefRange.beginOffset();
466 using MapInfo = llvm::DenseMapInfo<include_cleaner::Symbol>;
467 return MapInfo::getHashValue(LHS.Symbol) <
468 MapInfo::getHashValue(RHS.Symbol);
470 MissingIncludes.erase(llvm::unique(MissingIncludes), MissingIncludes.end());
471 std::vector<const Inclusion *> UnusedIncludes = getUnused(
AST, Used);
472 return {std::move(UnusedIncludes), std::move(MissingIncludes)};
476 const include_cleaner::Includes &Includes,
477 llvm::ArrayRef<include_cleaner::Header> Providers) {
478 for (
const auto &H : Providers) {
479 auto Matches = Includes.match(H);
480 for (
const include_cleaner::Include *Match : Matches)
481 if (Match->Line ==
unsigned(Inc.
HashLine + 1))
483 if (!Matches.empty())
493 trace::Span Tracer(
"IncludeCleaner::issueIncludeCleanerDiagnostics");
494 std::vector<Diag> UnusedIncludes = generateUnusedIncludeDiagnostics(
496 std::optional<Fix> RemoveAllUnused = removeAllUnusedIncludes(UnusedIncludes);
498 std::vector<Diag> MissingIncludeDiags = generateMissingIncludeDiagnostics(
500 std::optional<Fix> AddAllMissing = addAllMissingIncludes(MissingIncludeDiags);
502 std::optional<Fix> FixAll;
503 if (RemoveAllUnused && AddAllMissing)
504 FixAll = fixAll(*RemoveAllUnused, *AddAllMissing);
509 Out->Fixes.push_back(*F);
511 for (
auto &
Diag : MissingIncludeDiags) {
512 AddBatchFix(MissingIncludeDiags.size() > 1 ? AddAllMissing : std::nullopt,
514 AddBatchFix(FixAll, &
Diag);
516 for (
auto &
Diag : UnusedIncludes) {
517 AddBatchFix(UnusedIncludes.size() > 1 ? RemoveAllUnused : std::nullopt,
519 AddBatchFix(FixAll, &
Diag);
522 auto Result = std::move(MissingIncludeDiags);
523 llvm::move(UnusedIncludes, std::back_inserter(Result));
CompiledFragmentImpl & Out
Include Cleaner is clangd functionality for providing diagnostics for misuse of transitive headers an...
Stores and provides access to parsed AST.
Stores information required to parse a TU using a (possibly stale) Baseline preamble.
static OptionalFileEntryRef getPatchEntry(llvm::StringRef MainFilePath, const SourceManager &SM)
Returns the FileEntry for the preamble patch of MainFilePath in SM, if any.
Records an event whose duration is the lifetime of the Span object.
Position offsetToPosition(llvm::StringRef Code, size_t Offset)
Turn an offset in Code into a [line, column] pair.
IncludeCleanerFindings computeIncludeCleanerFindings(ParsedAST &AST)
std::vector< include_cleaner::SymbolReference > collectMacroReferences(ParsedAST &AST)
include_cleaner::Includes convertIncludes(const ParsedAST &AST)
Converts the clangd include representation to include-cleaner include representation.
std::optional< DefinedMacro > locateMacroAt(const syntax::Token &SpelledTok, Preprocessor &PP)
Gets the macro referenced by SpelledTok.
std::vector< Diag > issueIncludeCleanerDiagnostics(ParsedAST &AST, llvm::StringRef Code, const IncludeCleanerFindings &Findings, HeaderFilter IgnoreHeaders)
std::string ChangeAnnotationIdentifier
bool isPreferredProvider(const Inclusion &Inc, const include_cleaner::Includes &Includes, llvm::ArrayRef< include_cleaner::Header > Providers)
Whether this #include is considered to provide a particular symbol.
@ Unnecessary
Unused or unnecessary code.
llvm::ArrayRef< std::function< bool(llvm::StringRef)> > HeaderFilter
clangd::Range rangeTillEOL(llvm::StringRef Code, unsigned HashOffset)
Returns the range starting at offset and spanning the whole line.
llvm::StringRef PathRef
A typedef to represent a ref to file path.
void elog(const char *Fmt, Ts &&... Vals)
TextEdit replacementToEdit(llvm::StringRef Code, const tooling::Replacement &R)
A top-level diagnostic that may have Notes and Fixes.
std::vector< const Inclusion * > UnusedIncludes
std::vector< MissingIncludeDiagInfo > MissingIncludes
Represents a symbol occurrence in the source file.