18#include "clang-include-cleaner/Analysis.h"
19#include "clang-include-cleaner/IncludeSpeller.h"
20#include "clang-include-cleaner/Record.h"
21#include "clang-include-cleaner/Types.h"
25#include "clang/AST/ASTContext.h"
26#include "clang/AST/DeclCXX.h"
27#include "clang/AST/Expr.h"
28#include "clang/AST/ExprCXX.h"
29#include "clang/AST/TemplateName.h"
30#include "clang/AST/Type.h"
31#include "clang/Basic/Diagnostic.h"
32#include "clang/Basic/LLVM.h"
33#include "clang/Basic/SourceLocation.h"
34#include "clang/Basic/SourceManager.h"
35#include "clang/Format/Format.h"
36#include "clang/Lex/HeaderSearch.h"
37#include "clang/Lex/Preprocessor.h"
38#include "clang/Tooling/Core/Replacement.h"
39#include "clang/Tooling/Inclusions/HeaderIncludes.h"
40#include "clang/Tooling/Inclusions/StandardLibrary.h"
41#include "clang/Tooling/Syntax/Tokens.h"
42#include "llvm/ADT/ArrayRef.h"
43#include "llvm/ADT/DenseSet.h"
44#include "llvm/ADT/GenericUniformityImpl.h"
45#include "llvm/ADT/STLExtras.h"
46#include "llvm/ADT/STLFunctionalExtras.h"
47#include "llvm/ADT/SmallString.h"
48#include "llvm/ADT/SmallVector.h"
49#include "llvm/ADT/StringMap.h"
50#include "llvm/ADT/StringRef.h"
51#include "llvm/ADT/StringSet.h"
52#include "llvm/Support/Casting.h"
53#include "llvm/Support/Error.h"
54#include "llvm/Support/ErrorHandling.h"
55#include "llvm/Support/FormatVariadic.h"
56#include "llvm/Support/Path.h"
57#include "llvm/Support/Regex.h"
80 Result.end.character +=
82 return C ==
'\n' || C ==
'\r';
87bool isFilteredByConfig(
const Config &Cfg, llvm::StringRef HeaderPath) {
89 llvm::SmallString<64> NormalizedPath(HeaderPath);
90 llvm::sys::path::native(NormalizedPath, llvm::sys::path::Style::posix);
92 if (Filter(NormalizedPath))
98static bool mayConsiderUnused(
const Inclusion &Inc, ParsedAST &
AST,
100 const include_cleaner::PragmaIncludes *PI) {
104 if (Inc.Written.front() ==
'<') {
105 if (
AnalyzeStdlib && tooling::stdlib::Header::named(Inc.Written))
109 assert(Inc.HeaderID);
111 auto FE =
AST.getSourceManager().getFileManager().getFileRef(
112 AST.getIncludeStructure().getRealPath(HID));
115 if (PI->shouldKeep(Inc.HashLine + 1))
119 if (
auto PHeader = PI->getPublic(*FE); !PHeader.empty()) {
120 PHeader = PHeader.trim(
"<>\"");
124 if (
AST.tuPath().endswith(PHeader))
130 if (!
AST.getPreprocessor().getHeaderSearchInfo().isFileMultipleIncludeGuarded(
131 &FE->getFileEntry())) {
132 dlog(
"{0} doesn't have header guard and will not be considered unused",
137 if (isFilteredByConfig(Cfg, Inc.Resolved)) {
138 dlog(
"{0} header is filtered out by the configuration", FE->getName());
144llvm::StringRef getResolvedPath(
const include_cleaner::Header &SymProvider) {
145 switch (SymProvider.kind()) {
146 case include_cleaner::Header::Physical:
147 return SymProvider.physical()->tryGetRealPathName();
148 case include_cleaner::Header::Standard:
149 return SymProvider.standard().name().trim(
"<>\"");
150 case include_cleaner::Header::Verbatim:
151 return SymProvider.verbatim().trim(
"<>\"");
153 llvm_unreachable(
"Unknown header kind");
156std::string getSymbolName(
const include_cleaner::Symbol &Sym) {
157 switch (Sym.kind()) {
158 case include_cleaner::Symbol::Macro:
159 return Sym.macro().Name->getName().str();
160 case include_cleaner::Symbol::Declaration:
161 return llvm::dyn_cast<NamedDecl>(&Sym.declaration())
162 ->getQualifiedNameAsString();
164 llvm_unreachable(
"Unknown symbol kind");
167std::vector<Diag> generateMissingIncludeDiagnostics(
168 ParsedAST &
AST, llvm::ArrayRef<MissingIncludeDiagInfo> MissingIncludes,
169 llvm::StringRef
Code) {
170 std::vector<Diag> Result;
178 const SourceManager &SM =
AST.getSourceManager();
179 const FileEntry *
MainFile = SM.getFileEntryForID(SM.getMainFileID());
181 auto FileStyle = format::getStyle(
182 format::DefaultFormatStyle,
AST.tuPath(), format::DefaultFallbackStyle,
183 Code, &SM.getFileManager().getVirtualFileSystem());
185 elog(
"Couldn't infer style", FileStyle.takeError());
186 FileStyle = format::getLLVMStyle();
189 tooling::HeaderIncludes HeaderIncludes(
AST.tuPath(),
Code,
190 FileStyle->IncludeStyle);
191 for (
const auto &SymbolWithMissingInclude : MissingIncludes) {
192 llvm::StringRef ResolvedPath =
193 getResolvedPath(SymbolWithMissingInclude.Providers.front());
194 if (isFilteredByConfig(Cfg, ResolvedPath)) {
195 dlog(
"IncludeCleaner: not diagnosing missing include {0}, filtered by "
201 std::string Spelling =
204 llvm::StringRef HeaderRef{Spelling};
205 bool Angled = HeaderRef.starts_with(
"<");
210 std::optional<tooling::Replacement> Replacement = HeaderIncludes.insert(
211 HeaderRef.trim(
"\"<>"), Angled, tooling::IncludeDirective::Include);
212 if (!Replacement.has_value())
215 Diag &
D = Result.emplace_back();
217 llvm::formatv(
"No header providing \"{0}\" is directly included",
218 getSymbolName(SymbolWithMissingInclude.Symbol));
219 D.Name =
"missing-includes";
221 D.File =
AST.tuPath();
222 D.InsideMainFile =
true;
239 D.Severity = DiagnosticsEngine::Note;
240 D.Range = clangd::Range{
242 SymbolWithMissingInclude.SymRefRange.beginOffset()),
244 SymbolWithMissingInclude.SymRefRange.endOffset())};
245 auto &F =
D.Fixes.emplace_back();
246 F.Message =
"#include " + Spelling;
248 F.Edits.emplace_back(std::move(Edit));
253std::vector<Diag> generateUnusedIncludeDiagnostics(
255 llvm::StringRef
Code) {
256 std::vector<Diag> Result;
263 for (
const auto *Inc : UnusedIncludes) {
264 Diag &
D = Result.emplace_back();
266 llvm::formatv(
"included header {0} is not used directly",
267 llvm::sys::path::filename(
268 Inc->Written.substr(1, Inc->Written.size() - 2),
269 llvm::sys::path::Style::posix));
270 D.Name =
"unused-includes";
273 D.InsideMainFile =
true;
274 D.Severity = DiagnosticsEngine::Warning;
276 D.Range = getDiagnosticRange(
Code, Inc->HashOffset);
282 auto &F =
D.Fixes.emplace_back();
283 F.Message =
"remove #include directive";
284 F.Edits.emplace_back();
285 F.Edits.back().range.start.line = Inc->HashLine;
286 F.Edits.back().range.end.line = Inc->HashLine + 1;
292std::vector<include_cleaner::SymbolReference>
294 const auto &SM =
AST.getSourceManager();
296 std::vector<include_cleaner::SymbolReference> Macros;
297 auto &PP =
AST.getPreprocessor();
298 for (
const syntax::Token &Tok :
299 AST.getTokens().spelledTokens(SM.getMainFileID())) {
303 if (
auto DefLoc =
Macro->Info->getDefinitionLoc(); DefLoc.isValid())
306 include_cleaner::Macro{PP.getIdentifierInfo(Tok.text(SM)),
308 include_cleaner::RefType::Explicit});
313include_cleaner::Includes
315 const llvm::ArrayRef<Inclusion> Includes) {
316 include_cleaner::Includes ConvertedIncludes;
318 include_cleaner::Include TransformedInc;
319 llvm::StringRef WrittenRef = llvm::StringRef(Inc.Written);
320 TransformedInc.Spelled = WrittenRef.trim(
"\"<>");
321 TransformedInc.HashLocation =
322 SM.getComposedLoc(SM.getMainFileID(), Inc.HashOffset);
323 TransformedInc.Line = Inc.HashLine + 1;
324 TransformedInc.Angled = WrittenRef.starts_with(
"<");
325 auto FE = SM.getFileManager().getFile(Inc.Resolved);
327 elog(
"IncludeCleaner: Failed to get an entry for resolved path {0}: {1}",
328 Inc.Resolved, FE.getError().message());
331 TransformedInc.Resolved = *FE;
332 ConvertedIncludes.add(std::move(TransformedInc));
334 return ConvertedIncludes;
338 include_cleaner::Header Provider) {
339 if (Provider.kind() == include_cleaner::Header::Physical) {
340 if (
auto CanonicalPath =
342 AST.getSourceManager().getFileManager())) {
343 std::string SpelledHeader =
345 if (!SpelledHeader.empty())
346 return SpelledHeader;
349 return include_cleaner::spellHeader(
350 {Provider,
AST.getPreprocessor().getHeaderSearchInfo(),
MainFile});
353std::vector<const Inclusion *>
355 const llvm::DenseSet<IncludeStructure::HeaderID> &ReferencedFiles,
356 const llvm::StringSet<> &ReferencedPublicHeaders) {
359 std::vector<const Inclusion *> Unused;
360 for (
const Inclusion &MFI :
AST.getIncludeStructure().MainFileIncludes) {
363 if (ReferencedPublicHeaders.contains(MFI.Written))
366 bool Used = ReferencedFiles.contains(IncludeID);
367 if (!Used && !mayConsiderUnused(MFI,
AST, Cfg,
AST.getPragmaIncludes())) {
368 dlog(
"{0} was not used, but is not eligible to be diagnosed as unused",
373 Unused.push_back(&MFI);
374 dlog(
"{0} is {1}", MFI.Written, Used ?
"USED" :
"UNUSED");
380 const auto &SM =
AST.getSourceManager();
381 const auto &Includes =
AST.getIncludeStructure();
382 include_cleaner::Includes ConvertedIncludes =
384 const FileEntry *
MainFile = SM.getFileEntryForID(SM.getMainFileID());
387 std::vector<include_cleaner::SymbolReference> Macros =
389 std::vector<MissingIncludeDiagInfo> MissingIncludes;
390 llvm::DenseSet<IncludeStructure::HeaderID> Used;
392 include_cleaner::walkUsed(
393 AST.getLocalTopLevelDecls(), Macros,
394 AST.getPragmaIncludes(), SM,
395 [&](
const include_cleaner::SymbolReference &
Ref,
396 llvm::ArrayRef<include_cleaner::Header> Providers) {
397 bool Satisfied = false;
398 for (const auto &H : Providers) {
399 if (H.kind() == include_cleaner::Header::Physical &&
400 (H.physical() == MainFile || H.physical() == PreamblePatch)) {
404 for (auto *Inc : ConvertedIncludes.match(H)) {
406 auto HeaderID = Includes.getID(Inc->Resolved);
407 assert(HeaderID.has_value() &&
408 "ConvertedIncludes only contains resolved includes.");
409 Used.insert(*HeaderID);
413 if (Satisfied || Providers.empty() ||
414 Ref.RT != include_cleaner::RefType::Explicit)
424 auto Loc = SM.getFileLoc(
Ref.RefLocation);
427 while (SM.getFileID(
Loc) != SM.getMainFileID())
428 Loc = SM.getIncludeLoc(SM.getFileID(
Loc));
429 auto TouchingTokens =
430 syntax::spelledTokensTouching(
Loc,
AST.getTokens());
431 assert(!TouchingTokens.empty());
436 Ref.Target, TouchingTokens.back().range(SM), Providers};
437 MissingIncludes.push_back(std::move(DiagInfo));
442 llvm::stable_sort(MissingIncludes, [](
const MissingIncludeDiagInfo &LHS,
443 const MissingIncludeDiagInfo &RHS) {
445 if (LHS.SymRefRange != RHS.SymRefRange) {
448 return LHS.SymRefRange.beginOffset() < RHS.SymRefRange.beginOffset();
452 using MapInfo = llvm::DenseMapInfo<include_cleaner::Symbol>;
453 return MapInfo::getHashValue(LHS.Symbol) <
454 MapInfo::getHashValue(RHS.Symbol);
456 MissingIncludes.erase(llvm::unique(MissingIncludes), MissingIncludes.end());
457 std::vector<const Inclusion *> UnusedIncludes =
459 return {std::move(UnusedIncludes), std::move(MissingIncludes)};
463 if (UnusedIncludes.empty())
467 RemoveAll.
Message =
"remove all unused includes";
468 for (
const auto &
Diag : UnusedIncludes) {
469 assert(
Diag.
Fixes.size() == 1 &&
"Expected exactly one fix.");
480 "RemoveAllUnusedIncludes";
481 for (
unsigned I = 0; I < RemoveAll.
Edits.size(); ++I) {
483 RemoveAll.
Edits[I].annotationId = ID;
490 if (MissingIncludeDiags.empty())
494 AddAllMissing.
Message =
"add all missing includes";
497 llvm::StringMap<TextEdit> Edits;
498 for (
const auto &
Diag : MissingIncludeDiags) {
499 assert(
Diag.
Fixes.size() == 1 &&
"Expected exactly one fix.");
501 Edits.try_emplace(
Edit.newText,
Edit);
509 "AddAllMissingIncludes";
511 for (
auto &It : Edits) {
513 AddAllMissing.
Edits.push_back(std::move(It.getValue()));
514 AddAllMissing.
Edits.back().annotationId = ID;
516 AddAllMissing.
Annotations.push_back({ID, Annotation});
518 return AddAllMissing;
522 FixAll.
Message =
"fix all includes";
524 for (
const auto &F : RemoveAllUnused.
Edits)
525 FixAll.
Edits.push_back(F);
526 for (
const auto &F : AddAllMissing.
Edits)
527 FixAll.
Edits.push_back(F);
538 llvm::StringRef
Code) {
539 std::vector<Diag> UnusedIncludes = generateUnusedIncludeDiagnostics(
543 std::vector<Diag> MissingIncludeDiags = generateMissingIncludeDiagnostics(
547 std::optional<Fix> FixAll;
548 if (RemoveAllUnused && AddAllMissing)
549 FixAll =
fixAll(*RemoveAllUnused, *AddAllMissing);
553 Out->Fixes.push_back(*F);
555 for (
auto &
Diag : MissingIncludeDiags) {
556 AddBatchFix(MissingIncludeDiags.size() > 1
560 AddBatchFix(FixAll, &
Diag);
562 for (
auto &
Diag : UnusedIncludes) {
563 AddBatchFix(UnusedIncludes.size() > 1 ? RemoveAllUnused
566 AddBatchFix(FixAll, &
Diag);
569 auto Result = std::move(MissingIncludeDiags);
570 llvm::move(UnusedIncludes,
571 std::back_inserter(Result));
576 llvm::StringRef
Code) {
578 if (AST.getLangOpts().ObjC)
581 trace::Span Tracer(
"IncludeCleaner::issueIncludeCleanerDiagnostics");
583 const Config &Cfg = Config::current();
585 if (Cfg.Diagnostics.MissingIncludes == Config::IncludesPolicy::Strict ||
586 Cfg.Diagnostics.UnusedIncludes == Config::IncludesPolicy::Strict) {
593std::optional<include_cleaner::Header>
595 llvm::ArrayRef<include_cleaner::Header> Providers) {
596 for (
const auto &H : Providers) {
597 if (!Includes.match(H).empty())
CompiledFragmentImpl & Out
Include Cleaner is clangd functionality for providing diagnostics for misuse of transitive headers an...
std::vector< Inclusion > MainFileIncludes
Stores and provides access to parsed AST.
Stores information required to parse a TU using a (possibly stale) Baseline preamble.
static const FileEntry * getPatchEntry(llvm::StringRef MainFilePath, const SourceManager &SM)
Returns the FileEntry for the preamble patch of MainFilePath in SM, if any.
static llvm::Expected< std::string > includeSpelling(const URI &U)
Gets the preferred spelling of this file for #include, if there is one, e.g.
static llvm::Expected< URI > create(llvm::StringRef AbsolutePath, llvm::StringRef Scheme)
Creates a URI for a file in the given scheme.
Records an event whose duration is the lifetime of the Span object.
std::vector< Diag > issueIncludeCleanerDiagnostics(ParsedAST &AST, llvm::StringRef Code)
std::optional< Fix > addAllMissingIncludes(llvm::ArrayRef< Diag > MissingIncludeDiags)
Position offsetToPosition(llvm::StringRef Code, size_t Offset)
Turn an offset in Code into a [line, column] pair.
size_t lspLength(llvm::StringRef Code)
Fix fixAll(const Fix &RemoveAllUnused, const Fix &AddAllMissing)
IncludeCleanerFindings computeIncludeCleanerFindings(ParsedAST &AST)
std::optional< Fix > removeAllUnusedIncludes(llvm::ArrayRef< Diag > UnusedIncludes)
std::vector< include_cleaner::SymbolReference > collectMacroReferences(ParsedAST &AST)
void setIncludeCleanerAnalyzesStdlib(bool B)
Affects whether standard library includes should be considered for removal.
std::vector< Diag > generateIncludeCleanerDiagnostic(ParsedAST &AST, const IncludeCleanerFindings &Findings, llvm::StringRef Code)
std::optional< DefinedMacro > locateMacroAt(const syntax::Token &SpelledTok, Preprocessor &PP)
Gets the macro referenced by SpelledTok.
static bool AnalyzeStdlib
std::optional< std::string > getCanonicalPath(const FileEntryRef F, FileManager &FileMgr)
Get the canonical path of F.
include_cleaner::Includes convertIncludes(const SourceManager &SM, const llvm::ArrayRef< Inclusion > Includes)
Converts the clangd include representation to include-cleaner include representation.
std::string ChangeAnnotationIdentifier
std::optional< include_cleaner::Header > firstMatchedProvider(const include_cleaner::Includes &Includes, llvm::ArrayRef< include_cleaner::Header > Providers)
Find the first provider in the list that is matched by the includes.
std::vector< const Inclusion * > getUnused(ParsedAST &AST, const llvm::DenseSet< IncludeStructure::HeaderID > &ReferencedFiles, const llvm::StringSet<> &ReferencedPublicHeaders)
Retrieves headers that are referenced from the main file but not used.
@ Unnecessary
Unused or unnecessary code.
std::string spellHeader(ParsedAST &AST, const FileEntry *MainFile, include_cleaner::Header Provider)
Determines the header spelling of an include-cleaner header representation.
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)
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Settings that express user/project preferences and control clangd behavior.
struct clang::clangd::Config::@4::@13 Includes
IncludeCleaner will not diagnose usages of these headers matched by these regexes.
static const Config & current()
Returns the Config of the current Context, or an empty configuration.
@ Strict
Diagnose missing and unused includes.
std::vector< std::function< bool(llvm::StringRef)> > IgnoreHeader
IncludesPolicy UnusedIncludes
IncludesPolicy MissingIncludes
struct clang::clangd::Config::@4 Diagnostics
Controls warnings and errors when parsing code.
A top-level diagnostic that may have Notes and Fixes.
std::vector< Fix > Fixes
Alternative fixes for this diagnostic, one should be chosen.
A set of edits generated for a single file.
Represents a single fix-it that editor can apply to fix the error.
llvm::SmallVector< std::pair< ChangeAnnotationIdentifier, ChangeAnnotation > > Annotations
Annotations for the Edits.
std::string Message
Message for the fix-it.
llvm::SmallVector< TextEdit, 1 > Edits
TextEdits from clang's fix-its. Must be non-empty.
std::vector< const Inclusion * > UnusedIncludes
std::vector< MissingIncludeDiagInfo > MissingIncludes
Represents a symbol occurrence in the source file.