clang-tools 19.0.0git
IncludeCleaner.cpp
Go to the documentation of this file.
1//===--- IncludeCleaner.cpp - Unused/Missing Headers Analysis ---*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "IncludeCleaner.h"
10#include "Diagnostics.h"
11#include "Headers.h"
12#include "ParsedAST.h"
13#include "Preamble.h"
14#include "Protocol.h"
15#include "SourceCode.h"
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"
20#include "support/Logger.h"
21#include "support/Path.h"
22#include "support/Trace.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"
48#include <cassert>
49#include <iterator>
50#include <map>
51#include <optional>
52#include <string>
53#include <utility>
54#include <vector>
55
56namespace clang::clangd {
57namespace {
58
59bool isIgnored(llvm::StringRef HeaderPath, HeaderFilter IgnoreHeaders) {
60 // Convert the path to Unix slashes and try to match against the filter.
61 llvm::SmallString<64> NormalizedPath(HeaderPath);
62 llvm::sys::path::native(NormalizedPath, llvm::sys::path::Style::posix);
63 for (auto &Filter : IgnoreHeaders) {
64 if (Filter(NormalizedPath))
65 return true;
66 }
67 return false;
68}
69
70bool mayConsiderUnused(const Inclusion &Inc, ParsedAST &AST,
71 const include_cleaner::PragmaIncludes *PI,
72 bool AnalyzeAngledIncludes) {
73 assert(Inc.HeaderID);
74 auto HID = static_cast<IncludeStructure::HeaderID>(*Inc.HeaderID);
75 auto FE = AST.getSourceManager().getFileManager().getFileRef(
76 AST.getIncludeStructure().getRealPath(HID));
77 assert(FE);
78 if (FE->getDir() == AST.getPreprocessor()
79 .getHeaderSearchInfo()
80 .getModuleMap()
81 .getBuiltinDir())
82 return false;
83 if (PI && PI->shouldKeep(*FE))
84 return false;
85 // FIXME(kirillbobyrev): We currently do not support the umbrella headers.
86 // System headers are likely to be standard library headers.
87 // Until we have good support for umbrella headers, don't warn about them
88 // (unless analysis is explicitly enabled).
89 if (Inc.Written.front() == '<') {
90 if (tooling::stdlib::Header::named(Inc.Written))
91 return true;
92 if (!AnalyzeAngledIncludes)
93 return false;
94 }
95 if (PI) {
96 // Check if main file is the public interface for a private header. If so we
97 // shouldn't diagnose it as unused.
98 if (auto PHeader = PI->getPublic(*FE); !PHeader.empty()) {
99 PHeader = PHeader.trim("<>\"");
100 // Since most private -> public mappings happen in a verbatim way, we
101 // check textually here. This might go wrong in presence of symlinks or
102 // header mappings. But that's not different than rest of the places.
103 if (AST.tuPath().ends_with(PHeader))
104 return false;
105 }
106 }
107 // Headers without include guards have side effects and are not
108 // self-contained, skip them.
109 if (!AST.getPreprocessor().getHeaderSearchInfo().isFileMultipleIncludeGuarded(
110 *FE)) {
111 dlog("{0} doesn't have header guard and will not be considered unused",
112 FE->getName());
113 return false;
114 }
115 return true;
116}
117
118std::vector<Diag> generateMissingIncludeDiagnostics(
119 ParsedAST &AST, llvm::ArrayRef<MissingIncludeDiagInfo> MissingIncludes,
120 llvm::StringRef Code, HeaderFilter IgnoreHeaders, const ThreadsafeFS &TFS) {
121 std::vector<Diag> Result;
122 const SourceManager &SM = AST.getSourceManager();
123 const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID());
124
125 auto FileStyle = getFormatStyleForFile(AST.tuPath(), Code, TFS, false);
126
127 tooling::HeaderIncludes HeaderIncludes(AST.tuPath(), Code,
128 FileStyle.IncludeStyle);
129 for (const auto &SymbolWithMissingInclude : MissingIncludes) {
130 llvm::StringRef ResolvedPath =
131 SymbolWithMissingInclude.Providers.front().resolvedPath();
132 if (isIgnored(ResolvedPath, IgnoreHeaders)) {
133 dlog("IncludeCleaner: not diagnosing missing include {0}, filtered by "
134 "config",
135 ResolvedPath);
136 continue;
137 }
138
139 std::string Spelling = include_cleaner::spellHeader(
140 {SymbolWithMissingInclude.Providers.front(),
141 AST.getPreprocessor().getHeaderSearchInfo(), MainFile});
142
143 llvm::StringRef HeaderRef{Spelling};
144 bool Angled = HeaderRef.starts_with("<");
145 // We might suggest insertion of an existing include in edge cases, e.g.,
146 // include is present in a PP-disabled region, or spelling of the header
147 // turns out to be the same as one of the unresolved includes in the
148 // main file.
149 std::optional<tooling::Replacement> Replacement = HeaderIncludes.insert(
150 HeaderRef.trim("\"<>"), Angled, tooling::IncludeDirective::Include);
151 if (!Replacement.has_value())
152 continue;
153
154 Diag &D = Result.emplace_back();
155 D.Message =
156 llvm::formatv("No header providing \"{0}\" is directly included",
157 SymbolWithMissingInclude.Symbol.name());
158 D.Name = "missing-includes";
159 D.Source = Diag::DiagSource::Clangd;
160 D.File = AST.tuPath();
161 D.InsideMainFile = true;
162 // We avoid the "warning" severity here in favor of LSP's "information".
163 //
164 // Users treat most warnings on code being edited as high-priority.
165 // They don't think of include cleanups the same way: they want to edit
166 // lines with existing violations without fixing them.
167 // Diagnostics at the same level tend to be visually indistinguishable,
168 // and a few missing includes can cause many diagnostics.
169 // Marking these as "information" leaves them visible, but less intrusive.
170 //
171 // (These concerns don't apply to unused #include warnings: these are fewer,
172 // they appear on infrequently-edited lines with few other warnings, and
173 // the 'Unneccesary' tag often result in a different rendering)
174 //
175 // Usually clang's "note" severity usually has special semantics, being
176 // translated into LSP RelatedInformation of a parent diagnostic.
177 // But not here: these aren't processed by clangd's DiagnosticConsumer.
178 D.Severity = DiagnosticsEngine::Note;
179 D.Range = clangd::Range{
181 SymbolWithMissingInclude.SymRefRange.beginOffset()),
183 SymbolWithMissingInclude.SymRefRange.endOffset())};
184 auto &F = D.Fixes.emplace_back();
185 F.Message = "#include " + Spelling;
186 TextEdit Edit = replacementToEdit(Code, *Replacement);
187 F.Edits.emplace_back(std::move(Edit));
188 }
189 return Result;
190}
191
192std::vector<Diag> generateUnusedIncludeDiagnostics(
193 PathRef FileName, llvm::ArrayRef<const Inclusion *> UnusedIncludes,
194 llvm::StringRef Code, HeaderFilter IgnoreHeaders) {
195 std::vector<Diag> Result;
196 for (const auto *Inc : UnusedIncludes) {
197 if (isIgnored(Inc->Resolved, IgnoreHeaders))
198 continue;
199 Diag &D = Result.emplace_back();
200 D.Message =
201 llvm::formatv("included header {0} is not used directly",
202 llvm::sys::path::filename(
203 Inc->Written.substr(1, Inc->Written.size() - 2),
204 llvm::sys::path::Style::posix));
205 D.Name = "unused-includes";
206 D.Source = Diag::DiagSource::Clangd;
207 D.File = FileName;
208 D.InsideMainFile = true;
209 D.Severity = DiagnosticsEngine::Warning;
210 D.Tags.push_back(Unnecessary);
211 D.Range = rangeTillEOL(Code, Inc->HashOffset);
212 // FIXME(kirillbobyrev): Removing inclusion might break the code if the
213 // used headers are only reachable transitively through this one. Suggest
214 // including them directly instead.
215 // FIXME(kirillbobyrev): Add fix suggestion for adding IWYU pragmas
216 // (keep/export) remove the warning once we support IWYU pragmas.
217 auto &F = D.Fixes.emplace_back();
218 F.Message = "remove #include directive";
219 F.Edits.emplace_back();
220 F.Edits.back().range.start.line = Inc->HashLine;
221 F.Edits.back().range.end.line = Inc->HashLine + 1;
222 }
223 return Result;
224}
225
226std::optional<Fix>
227removeAllUnusedIncludes(llvm::ArrayRef<Diag> UnusedIncludes) {
228 if (UnusedIncludes.empty())
229 return std::nullopt;
230
231 Fix RemoveAll;
232 RemoveAll.Message = "remove all unused includes";
233 for (const auto &Diag : UnusedIncludes) {
234 assert(Diag.Fixes.size() == 1 && "Expected exactly one fix.");
235 RemoveAll.Edits.insert(RemoveAll.Edits.end(),
236 Diag.Fixes.front().Edits.begin(),
237 Diag.Fixes.front().Edits.end());
238 }
239 return RemoveAll;
240}
241
242std::optional<Fix>
243addAllMissingIncludes(llvm::ArrayRef<Diag> MissingIncludeDiags) {
244 if (MissingIncludeDiags.empty())
245 return std::nullopt;
246
247 Fix AddAllMissing;
248 AddAllMissing.Message = "add all missing includes";
249 // A map to deduplicate the edits with the same new text.
250 // newText (#include "my_missing_header.h") -> TextEdit.
251 std::map<std::string, TextEdit> Edits;
252 for (const auto &Diag : MissingIncludeDiags) {
253 assert(Diag.Fixes.size() == 1 && "Expected exactly one fix.");
254 for (const auto &Edit : Diag.Fixes.front().Edits) {
255 Edits.try_emplace(Edit.newText, Edit);
256 }
257 }
258 for (auto &It : Edits)
259 AddAllMissing.Edits.push_back(std::move(It.second));
260 return AddAllMissing;
261}
262Fix fixAll(const Fix &RemoveAllUnused, const Fix &AddAllMissing) {
263 Fix FixAll;
264 FixAll.Message = "fix all includes";
265
266 for (const auto &F : RemoveAllUnused.Edits)
267 FixAll.Edits.push_back(F);
268 for (const auto &F : AddAllMissing.Edits)
269 FixAll.Edits.push_back(F);
270 return FixAll;
271}
272
273std::vector<const Inclusion *>
274getUnused(ParsedAST &AST,
275 const llvm::DenseSet<IncludeStructure::HeaderID> &ReferencedFiles,
276 bool AnalyzeAngledIncludes) {
277 trace::Span Tracer("IncludeCleaner::getUnused");
278 std::vector<const Inclusion *> Unused;
279 for (const Inclusion &MFI : AST.getIncludeStructure().MainFileIncludes) {
280 if (!MFI.HeaderID)
281 continue;
282 auto IncludeID = static_cast<IncludeStructure::HeaderID>(*MFI.HeaderID);
283 if (ReferencedFiles.contains(IncludeID))
284 continue;
285 if (!mayConsiderUnused(MFI, AST, &AST.getPragmaIncludes(),
286 AnalyzeAngledIncludes)) {
287 dlog("{0} was not used, but is not eligible to be diagnosed as unused",
288 MFI.Written);
289 continue;
290 }
291 Unused.push_back(&MFI);
292 }
293 return Unused;
294}
295
296} // namespace
297
298std::vector<include_cleaner::SymbolReference>
300 const auto &SM = AST.getSourceManager();
301 auto &PP = AST.getPreprocessor();
302 std::vector<include_cleaner::SymbolReference> Macros;
303 for (const auto &[_, Refs] : AST.getMacros().MacroRefs) {
304 for (const auto &Ref : Refs) {
305 auto Loc = SM.getComposedLoc(SM.getMainFileID(), Ref.StartOffset);
306 const auto *Tok = AST.getTokens().spelledTokenContaining(Loc);
307 if (!Tok)
308 continue;
309 auto Macro = locateMacroAt(*Tok, PP);
310 if (!Macro)
311 continue;
312 auto DefLoc = Macro->NameLoc;
313 if (!DefLoc.isValid())
314 continue;
315 Macros.push_back(
316 {include_cleaner::Macro{/*Name=*/PP.getIdentifierInfo(Tok->text(SM)),
317 DefLoc},
318 Tok->location(),
319 Ref.InConditionalDirective ? include_cleaner::RefType::Ambiguous
320 : include_cleaner::RefType::Explicit});
321 }
322 }
323
324 return Macros;
325}
326
327include_cleaner::Includes convertIncludes(const ParsedAST &AST) {
328 auto &SM = AST.getSourceManager();
329
330 include_cleaner::Includes ConvertedIncludes;
331 // We satisfy Includes's contract that search dirs and included files have
332 // matching path styles: both ultimately use FileManager::getCanonicalName().
333 for (const auto &Dir : AST.getIncludeStructure().SearchPathsCanonical)
334 ConvertedIncludes.addSearchDirectory(Dir);
335
336 for (const Inclusion &Inc : AST.getIncludeStructure().MainFileIncludes) {
337 include_cleaner::Include TransformedInc;
338 llvm::StringRef WrittenRef = llvm::StringRef(Inc.Written);
339 TransformedInc.Spelled = WrittenRef.trim("\"<>");
340 TransformedInc.HashLocation =
341 SM.getComposedLoc(SM.getMainFileID(), Inc.HashOffset);
342 TransformedInc.Line = Inc.HashLine + 1;
343 TransformedInc.Angled = WrittenRef.starts_with("<");
344 // Inc.Resolved is canonicalized with clangd::getCanonicalPath(),
345 // which is based on FileManager::getCanonicalName(ParentDir).
346 auto FE = SM.getFileManager().getFileRef(Inc.Resolved);
347 if (!FE) {
348 elog("IncludeCleaner: Failed to get an entry for resolved path {0}: {1}",
349 Inc.Resolved, FE.takeError());
350 continue;
351 }
352 TransformedInc.Resolved = *FE;
353 ConvertedIncludes.add(std::move(TransformedInc));
354 }
355 return ConvertedIncludes;
356}
357
358IncludeCleanerFindings
359computeIncludeCleanerFindings(ParsedAST &AST, bool AnalyzeAngledIncludes) {
360 // Interaction is only polished for C/CPP.
361 if (AST.getLangOpts().ObjC)
362 return {};
363 const auto &SM = AST.getSourceManager();
364 include_cleaner::Includes ConvertedIncludes = convertIncludes(AST);
365 const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID());
367
368 std::vector<include_cleaner::SymbolReference> Macros =
370 std::vector<MissingIncludeDiagInfo> MissingIncludes;
371 llvm::DenseSet<IncludeStructure::HeaderID> Used;
372 trace::Span Tracer("include_cleaner::walkUsed");
373 OptionalDirectoryEntryRef ResourceDir = AST.getPreprocessor()
374 .getHeaderSearchInfo()
375 .getModuleMap()
376 .getBuiltinDir();
377 include_cleaner::walkUsed(
378 AST.getLocalTopLevelDecls(), /*MacroRefs=*/Macros,
379 &AST.getPragmaIncludes(), AST.getPreprocessor(),
380 [&](const include_cleaner::SymbolReference &Ref,
381 llvm::ArrayRef<include_cleaner::Header> Providers) {
382 bool Satisfied = false;
383 for (const auto &H : Providers) {
384 if (H.kind() == include_cleaner::Header::Physical &&
385 (H.physical() == MainFile || H.physical() == PreamblePatch ||
386 H.physical().getDir() == ResourceDir)) {
387 Satisfied = true;
388 continue;
389 }
390 for (auto *Inc : ConvertedIncludes.match(H)) {
391 Satisfied = true;
392 auto HeaderID =
393 AST.getIncludeStructure().getID(&Inc->Resolved->getFileEntry());
394 assert(HeaderID.has_value() &&
395 "ConvertedIncludes only contains resolved includes.");
396 Used.insert(*HeaderID);
397 }
398 }
399
400 if (Satisfied || Providers.empty() ||
401 Ref.RT != include_cleaner::RefType::Explicit)
402 return;
403
404 // We actually always want to map usages to their spellings, but
405 // spelling locations can point into preamble section. Using these
406 // offsets could lead into crashes in presence of stale preambles. Hence
407 // we use "getFileLoc" instead to make sure it always points into main
408 // file.
409 // FIXME: Use presumed locations to map such usages back to patched
410 // locations safely.
411 auto Loc = SM.getFileLoc(Ref.RefLocation);
412 // File locations can be outside of the main file if macro is expanded
413 // through an #include.
414 while (SM.getFileID(Loc) != SM.getMainFileID())
415 Loc = SM.getIncludeLoc(SM.getFileID(Loc));
416 auto TouchingTokens =
417 syntax::spelledTokensTouching(Loc, AST.getTokens());
418 assert(!TouchingTokens.empty());
419 // Loc points to the start offset of the ref token, here we use the last
420 // element of the TouchingTokens, e.g. avoid getting the "::" for
421 // "ns::^abc".
422 MissingIncludeDiagInfo DiagInfo{
423 Ref.Target, TouchingTokens.back().range(SM), Providers};
424 MissingIncludes.push_back(std::move(DiagInfo));
425 });
426 // Put possibly equal diagnostics together for deduplication.
427 // The duplicates might be from macro arguments that get expanded multiple
428 // times.
429 llvm::stable_sort(MissingIncludes, [](const MissingIncludeDiagInfo &LHS,
430 const MissingIncludeDiagInfo &RHS) {
431 // First sort by reference location.
432 if (LHS.SymRefRange != RHS.SymRefRange) {
433 // We can get away just by comparing the offsets as all the ranges are in
434 // main file.
435 return LHS.SymRefRange.beginOffset() < RHS.SymRefRange.beginOffset();
436 }
437 // For the same location, break ties using the symbol. Note that this won't
438 // be stable across runs.
439 using MapInfo = llvm::DenseMapInfo<include_cleaner::Symbol>;
440 return MapInfo::getHashValue(LHS.Symbol) <
441 MapInfo::getHashValue(RHS.Symbol);
442 });
443 MissingIncludes.erase(llvm::unique(MissingIncludes), MissingIncludes.end());
444 std::vector<const Inclusion *> UnusedIncludes =
445 getUnused(AST, Used, AnalyzeAngledIncludes);
446 return {std::move(UnusedIncludes), std::move(MissingIncludes)};
447}
448
450 const include_cleaner::Includes &Includes,
451 llvm::ArrayRef<include_cleaner::Header> Providers) {
452 for (const auto &H : Providers) {
453 auto Matches = Includes.match(H);
454 for (const include_cleaner::Include *Match : Matches)
455 if (Match->Line == unsigned(Inc.HashLine + 1))
456 return true; // this header is (equal) best
457 if (!Matches.empty())
458 return false; // another header is better
459 }
460 return false; // no header provides the symbol
461}
462
463std::vector<Diag>
465 const IncludeCleanerFindings &Findings,
466 const ThreadsafeFS &TFS,
467 HeaderFilter IgnoreHeaders) {
468 trace::Span Tracer("IncludeCleaner::issueIncludeCleanerDiagnostics");
469 std::vector<Diag> UnusedIncludes = generateUnusedIncludeDiagnostics(
470 AST.tuPath(), Findings.UnusedIncludes, Code, IgnoreHeaders);
471 std::optional<Fix> RemoveAllUnused = removeAllUnusedIncludes(UnusedIncludes);
472
473 std::vector<Diag> MissingIncludeDiags = generateMissingIncludeDiagnostics(
474 AST, Findings.MissingIncludes, Code, IgnoreHeaders, TFS);
475 std::optional<Fix> AddAllMissing = addAllMissingIncludes(MissingIncludeDiags);
476
477 std::optional<Fix> FixAll;
478 if (RemoveAllUnused && AddAllMissing)
479 FixAll = fixAll(*RemoveAllUnused, *AddAllMissing);
480
481 auto AddBatchFix = [](const std::optional<Fix> &F, clang::clangd::Diag *Out) {
482 if (!F)
483 return;
484 Out->Fixes.push_back(*F);
485 };
486 for (auto &Diag : MissingIncludeDiags) {
487 AddBatchFix(MissingIncludeDiags.size() > 1 ? AddAllMissing : std::nullopt,
488 &Diag);
489 AddBatchFix(FixAll, &Diag);
490 }
491 for (auto &Diag : UnusedIncludes) {
492 AddBatchFix(UnusedIncludes.size() > 1 ? RemoveAllUnused : std::nullopt,
493 &Diag);
494 AddBatchFix(FixAll, &Diag);
495 }
496
497 auto Result = std::move(MissingIncludeDiags);
498 llvm::move(UnusedIncludes, std::back_inserter(Result));
499 return Result;
500}
501
502} // namespace clang::clangd
CompiledFragmentImpl & Out
std::string Code
std::string MainFile
Include Cleaner is clangd functionality for providing diagnostics for misuse of transitive headers an...
StringRef FileName
SourceLocation Loc
#define dlog(...)
Definition: Logger.h:101
Stores and provides access to parsed AST.
Definition: ParsedAST.h:46
Stores information required to parse a TU using a (possibly stale) Baseline preamble.
Definition: Preamble.h:171
static OptionalFileEntryRef getPatchEntry(llvm::StringRef MainFilePath, const SourceManager &SM)
Returns the FileEntry for the preamble patch of MainFilePath in SM, if any.
Definition: Preamble.cpp:965
Wrapper for vfs::FileSystem for use in multithreaded programs like clangd.
Definition: ThreadsafeFS.h:26
Records an event whose duration is the lifetime of the Span object.
Definition: Trace.h:143
Position offsetToPosition(llvm::StringRef Code, size_t Offset)
Turn an offset in Code into a [line, column] pair.
Definition: SourceCode.cpp:202
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.
Definition: SourceCode.cpp:999
std::vector< Diag > issueIncludeCleanerDiagnostics(ParsedAST &AST, llvm::StringRef Code, const IncludeCleanerFindings &Findings, const ThreadsafeFS &TFS, HeaderFilter IgnoreHeaders)
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.
IncludeCleanerFindings computeIncludeCleanerFindings(ParsedAST &AST, bool AnalyzeAngledIncludes)
@ Unnecessary
Unused or unnecessary code.
Definition: Protocol.h:901
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.
Definition: Path.h:29
void elog(const char *Fmt, Ts &&... Vals)
Definition: Logger.h:61
TextEdit replacementToEdit(llvm::StringRef Code, const tooling::Replacement &R)
Definition: SourceCode.cpp:504
format::FormatStyle getFormatStyleForFile(llvm::StringRef File, llvm::StringRef Content, const ThreadsafeFS &TFS, bool FormatFile)
Choose the clang-format style we should apply to a certain file.
Definition: SourceCode.cpp:583
A top-level diagnostic that may have Notes and Fixes.
Definition: Diagnostics.h:98
std::vector< const Inclusion * > UnusedIncludes
std::vector< MissingIncludeDiagInfo > MissingIncludes
Represents a symbol occurrence in the source file.
Definition: Ref.h:85